txt
stringlengths 93
37.3k
|
|---|
## dist_cpan-MARTIMM-BSON.md
# Face BSON support
Implements [BSON specification](http://bsonspec.org/).
  
## Synopsis
The main entry point is BBSON::Document. This structure is a Hash like object but will keep the order of its keys and because of that there is no need for cumbersome operations. At the moment it is much slower than the hashed variant even with the encoding happening in the background and parallel.
```
use BSON::Document;
my BSON::Javascript $js .= new(:javascript('function(x){return x;}'));
my BSON::Javascript $js-scope .= new(
:javascript('function(x){return x;}'),
:scope(BSON::Document.new: (nn => 10, a1 => 2))
);
my BSON::Binary $bin .= new(:data(Buf,new(... some binary data ...));
my BSON::Regex $rex .= new( :regex('abc|def'), :options<is>);
my BSON::Document $d .= new: ( 'a number' => 10, 'some text' => 'bla die bla');
$d<oid> = BSON::ObjectId.new;
$d<javascript> = $js;
$d<js-scope> = $js-scope;
$d<datetime> = DateTime.now;
$d<bin> = $bin;
$d<rex> = $rex;
$d<null> = Any;
$d<array> = [ 10, 'abc', 345];
$d<subdoc1> = a1 => 10, bb => 11;
$d<subdoc1><b1> = q => 255;
my Buf $enc-doc = $d.encode;
my BSON::Document $new-doc .= new;
$new-doc.decode($enc-doc);
```
## Documentation
BSON/Document.pod
* 🔗 Website
* [🔗 Travis-ci run on master branch](https://travis-ci.com/MARTIMM/BSON)
* [🔗 Appveyor run on master branch](https://ci.appveyor.com/project/MARTIMM/BSON/branch/master)
* [🔗 License document](https://www.perlfoundation.org/artistic_license_2_0)
* [🔗 Release notes](https://martimm.github.io/raku-mongodb-driver/content-docs/about/release-notes.html)
* [🔗 Issues](https://github.com/MARTIMM/raku-mongodb-driver/issues)
## Installing BSON
Use zef to install the package like so.
```
$ zef install BSON
```
When installing MongoDB, BSON will be installed automatically as a dependency.
## Version of Raku and MoarVM
This module is tested using the latest Raku version on MoarVM
## Authors
Original creator of the modules is Pawel Pabian (2011-2015, v0.3)(bbkr on github).
Current maintainer Marcel Timmerman (2015-present)(MARTIMM on github).
## Contributors
Dan Zwell (lefth on github)
|
## dist_zef-jjmerelo-LibraryMake.md
## LibraryMake
[](https://github.com/retupmoca/P6-LibraryMake/actions/workflows/test.yml) [](https://github.com/retupmoca/P6-LibraryMake/actions/workflows/nixos.yml)
An attempt to simplify building native code for a
[Raku](https://raku.org) module. It should work on all platforms, as long as
specified tools are available locally.
This is effectively a small configure script for a Makefile. It will allow you to
use the same tools to build your native code that were used to build Raku itself.
Typically, this will be used in both `Build.rakumod` (to support installation using a
module manager), and in a standalone `Configure.raku` script in the `src` directory
(to support standalone testing/building). Note that if you need additional
custom configure code, you will currently need to add it to both your `Build.rakumod`
and to your `Configure.raku`.
## Example Usage
The below files are examples of what you would write in your own project.
The `src` directory is merely a convention, and the `Makefile.in` will likely be
significantly different in your own project.
/Build.rakumod
```
use LibraryMake;
use Shell::Command;
my $libname = 'chelper';
class Build {
method build($dir) {
my %vars = get-vars($dir);
%vars{$libname} = $*VM.platform-library-name($libname.IO);
mkdir "$dir/resources" unless "$dir/resources".IO.e;
mkdir "$dir/resources/libraries" unless "$dir/resources/libraries".IO.e;
process-makefile($dir, %vars);
my $goback = $*CWD;
chdir($dir);
shell(%vars<MAKE>);
chdir($goback);
}
}
```
`src/Configure.raku`
```
#!/usr/bin/env raku
use LibraryMake;
my $libname = 'chelper';
my %vars = get-vars('.');
%vars{$libname} = $*VM.platform-library-name($libname.IO);
mkdir "resources" unless "resources".IO.e;
mkdir "resources/libraries" unless "resources/libraries".IO.e;
process-makefile('.', %vars);
shell(%vars<MAKE>);
say "Configure completed! You can now run '%vars<MAKE>' to build lib$libname.";
```
`src/Makefile.in` (Make sure you use TABs and not spaces!)
```
.PHONY: clean test
all: %DESTDIR%/resources/libraries/%chelper%
clean:
-rm %DESTDIR%/resources/libraries/%chelper% %DESTDIR%/*.o
%DESTDIR%/resources/libraries/%chelper%: chelper%O%
%LD% %LDSHARED% %LDFLAGS% %LIBS% %LDOUT%%DESTDIR%/resources/libraries/%chelper% chelper%O%
chelper%O%: src/chelper.c
%CC% -c %CCSHARED% %CCFLAGS% %CCOUT% chelper%O% src/chelper.c
test: all
prove -e "raku -Ilib" t
```
/lib/My/Module.rakumod
```
# ...
use NativeCall;
use LibraryMake;
constant CHELPER = %?RESOURCES<libraries/chelper>.absolute;
sub foo() is native( CHELPER ) { * };
```
Include the following section in your META6.json:
```
"resources" : [
"library/chelper"
],
"depends" : [
"LibraryMake"
]
```
## Functions
### sub get-vars
```
sub get-vars(
Str $destfolder
) returns Hash
```
Returns configuration variables. Effectively just a wrapper around $\*VM.config, as the VM config variables are different for each backend VM.
### sub process-makefile
```
sub process-makefile(
Str $folder,
%vars
) returns Mu
```
Takes '$folder/Makefile.in' and writes out '$folder/Makefile'. %vars should be the result of `get-vars` above.
### sub make
```
sub make(
Str $folder,
Str $destfolder
) returns Mu
```
Calls `get-vars` and `process-makefile` for you to generate '$folder/Makefile', then runs your system's 'make' to build it.
### sub build-tools-installed()
```
sub build-tools-installed(
) returns Bool
```
Returns True if the configured compiler(CC), linker(LD) and make program(MAKE) have been installed on this sytem system.
## Change log
* [1.0.4](https://github.com/retupmoca/P6-LibraryMake/releases/tag/v1.0.4) Reinstates macOS test and eliminates test that fails in it.
* [1.0.3](https://github.com/retupmoca/P6-LibraryMake/releases/tag/v1.0.3) Fixes files included in zef.
* [1.0.2](https://github.com/retupmoca/P6-LibraryMake/releases/tag/v1.0.2) Fixes test error when `prove6` is installed as test runner and
picked up by `zef`.
* [1.0.1](https://github.com/retupmoca/P6-LibraryMake/releases/tag/v1.0.1) Checks that the directory it's writing is writable, errors if it
does not
* [1.0.0](https://github.com/retupmoca/P6-LibraryMake/releases/tag/v1.0.0) Original version, newly released to the zef ecosystem.
|
## dist_github-mattn-Growl-GNTP.md
[](https://travis-ci.org/mattn/p6-Growl-GNTP)
# NAME
Growl::GNTP - blah blah blah
# SYNOPSIS
```
use Growl::GNTP;
```
# DESCRIPTION
Growl::GNTP is ...
# COPYRIGHT AND LICENSE
Copyright 2015 Yasuhiro Matsumoto [mattn.jp@gmail.com](mailto:mattn.jp@gmail.com)
This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.
|
## dist_zef-CIAvash-Sway-PreviewKeys.md
# NAME
sway-preview-keys - Shows preview windows for [Sway](https://swaywm.org/) modes' key bindings
# DESCRIPTION
Gets the config from sway and parses it.
Gets the CSS style for preview windows from path specified via command option or `$XDG_CONFIG_HOME/sway-preview-keys/style.css` or `$HOME/.config/sway-preview-keys/style.css`
Finally listens to Sway mode changes and shows a preview window for mode's key bindings.
# SYNOPSIS
```
Usage:
sway-preview-keys
[-p|--style-path<PATH>] -- Set CSS style path for preview window [p=path]
[-t|--add-mode-name] -- Add mode name at top of the preview window [t=title]
[-s|--sort-key-bindings] -- Sort mode's key bindings [s=sort]
[-d|--bindsym-default-mode=<NAME>] -- Bind a symbol for previewing key bindings of default mode [d=default]
[-f|--filter-out=<REGEX>] -- Exclude commands which match REGEX. Can be repeated. [f=filter]
REGEX is a Raku regex: https://docs.raku.org/language/regexes
[-r|--max-rows=<NUM>] -- Add columns to show key bindings when number of key bindings exceed the maximum row. Can be repeated. [r=row]
Biggest number which is lower than the number of key bindings is chosen, otherwise the minimum of the numbers is used
[-e|--ellipsize=<NUM>] -- Ellipsize commands, given number is used for maximum characters to show. [e=ellipsize]
Takes effect only when number of key bindings reaches the maximum of --max-rows
[--ellipsis-position=<start|center|end>] -- Set the position of ellipsis. Default is center.
Takes effect only when --ellipsize is used
sway-preview-keys -v|--version -- Print version
sway-preview-keys -h|--help -- Print help
Example:
sway-preview-keys -d 'Mod4+o' -t -e 26 -r 20 -r 38
sway-preview-keys --bindsym-default-mode 'Mod4+o' --add-mode-name --ellipsize 26 --max-rows 20 --max-rows 38
sway-preview-keys -d 'Mod4+o' -t -e 55 -r 20 -r 38 -f ':s workspace number' -f '^ focus' -f ':s ^move < right left up down >'
```
Example style:
```
#preview-window {
font-family: monospace;
background-color: rgba(43, 24, 21, 0.9);
color: white;
border-radius: 10px;
}
#preview-table {
padding: 2px 2px;
}
#mode-name {
font-weight: bold;
color: #CC7744;
margin: 0 7px;
padding: 4px 0;
border-bottom: 1px solid rgba(95, 75, 72, 0.9);
}
#key-binding, #command {
padding: 4px 7px;
}
#key-binding {
color: wheat;
}
#command {
color: #ddd;
}
```
# INSTALLATION
You need to have [GTK Layer Shell](https://github.com/wmww/gtk-layer-shell), [Raku](https://www.raku-lang.ir/en) and [zef](https://github.com/ugexe/zef), then run:
```
zef install --/test "Sway::PreviewKeys:auth<zef:CIAvash>"
```
or if you have cloned the repo:
```
zef install .
```
# TESTING
```
prove -ve 'raku -I.' --ext rakutest
```
# REPOSITORY
<https://codeberg.org/CIAvash/Sway-PreviewKeys>
# BUG
<https://codeberg.org/CIAvash/Sway-PreviewKeys/issues>
# AUTHOR
Siavash Askari Nasr - <https://siavash.askari-nasr.com>
# COPYRIGHT
Copyright © 2021 Siavash Askari Nasr
# LICENSE
Sway::PreviewKeys is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
Sway::PreviewKeys is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with Sway::PreviewKeys. If not, see <http://www.gnu.org/licenses/>.
|
## dist_cpan-SCHROEDER-Oddmuse6.md
# Oddmuse 6
This file is for the people wanting to download and install Oddmuse 6.
This is Oddmuse based on [Raku](https://raku.org/) and
[Cro](https://cro.services/).
If you're a developer, see the [to do list](docs/TODO.md).
If you're curious, see the [feature list](docs/FEATURES.md).
**Table of Contents**
* [Quickstart](#quickstart)
* [Development](#development)
* [Bugs](#bugs)
* [Test](#test)
* [Configuration](#configuration)
* [Changes](#changes)
* [Resources](#resources)
* [Images and CSS](#images-and-css)
* [Templates](#templates)
* [Wiki](#wiki)
* [Example: Changing the CSS](#example-changing-the-css)
* [Spam Protection](#spam-protection)
* [Hosting Multiple Wikis](#hosting-multiple-wikis)
* [Docker](#docker)
## Quickstart
Install Cro:
```
zef install --/test cro
```
Install Oddmuse 6:
```
zef install Oddmuse6
```
Create a new application by start with a stub and accepting all the
defaults:
```
cro stub http test test
```
This creates a service called "test" in a directory called `test`. If
you accept all the defaults, you'll get a service doing HTTP 1.1. Good
enough for us!
Now edit `test/services.p6` and replace `use Routes` with `use Oddmuse::Routes`.
You can delete the `test/lib/Routes.pm6` which `cro stub` generated
for you.
Your default wiki directory is `test/wiki`, so we need to tell `cro`
to ignore it. If you don't, you'll confuse `cro` to no end as soon as
you start editing files! Add the following section to your in
`test/.cro.yml` file:
```
ignore:
- wiki/
```
Run it:
```
cd test
cro run
```
Check it out by visiting `http://localhost:20000`. Your wiki is ready!
🙃
Let's configure it by setting an environment variable. More on this
[below](#configuration). Replace the empty environment section in
`test/.cro.yml` with the following and restart `cro`:
```
env:
- name: ODDMUSE_MENU
value: Home, Changes, About
```
And now you have a link to the *About* page. Follow the link and click
the *create it* link. Write the following into the text area and click
the *Save* button:
```
# About
This is my page.
```
Your first edit! 🎉
In order to make it public, you'll need to set two environment
variables. Each `cro` service gets to environment variables that
determine its *host* and its *port*. Their names depend on the name
you provided when you called `cro stub`. If you called it `test` like
I did in the example above, the two environment variables you need are
called `TEST_HOST` and `TEST_PORT`. Feel free to change them in
`service.p6` and `.cro.yml`, though.
## Development
Get the sources:
```
git clone https://alexschroeder.ch/cgit/oddmuse6
```
To run it, you need to install the dependencies:
```
cd oddmuse6
zef install --depsonly .
```
Then start the service:
```
cro run
```
This should start the wiki on http://localhost:20000/ and its data is
saved in the `wiki` directory.
## Bleeding Edge
If you installed a regular version of the wiki and now you want to
switch to the code in your working directory, use the following in
your working directory. It tests and installs the current version, and
its dependencies.
```
zef install --force-install .
```
## Bugs
🔥 When installing dependencies using `zef` as shown, you could be
running into an OpenSSL issue even if you have the correct development
libraries installed. On Debian, you need `libssl-dev` but apparently
versions 1.1.0f and 1.1.0g won't work. See
[issue #34](https://github.com/jnthn/p6-io-socket-async-ssl/issues/34).
You could decide to ignore SSL support and opt to have a web server
act as a proxy which provides SSL. That's what I intend to do. In
which case there is a terrible workaround available: run `zef install --force-test IO::Socket::Async::SSL` before you `zef install Oddmuse6`.
🔥 Every now and then I run into the error `This type (NQPMu) does not support associative operations` while I'm working on the code. As it
turns out, `rm -rf lib/.precomp` solves this issue. You'll be doing
this a lot until
[issue #2294](https://github.com/rakudo/rakudo/issues/2294) gets fixed.
🔥 When I ran into the error `Type check failed in binding $high; expected Any but got Mu` when computing a `diff` I found [issue
#12](https://github.com/Takadonet/Algorithm--Diff/issues/12) for
`Algorithm::Diff`. It's supposed to be fixed, now. One way to work
around it is to check it out and install it from source:
```
git clone https://github.com/Takadonet/Algorithm--Diff
cd Algorithm--Diff
zef install --force-install .
```
## Test
The `Makefile` has a `test` target. Use the `jobs` environment
variable to control how many jobs run in parallel. The default is 4.
```
jobs=1 make test
```
Running tests create test data directories (`test-nnnn`). This allows
us to run multiple tests in parallel. The directories are kept around
for developers to inspect in case something went wrong. Eventually,
you'll need to clean these up:
```
make clean
```
To run just one suite of tests:
```
make t/keep.t
```
This also shows you the data directory it uses:
```
Using test-1288
```
## Configuration
If you look at the `oddmuse/.cro.yml` file you'll find a section with
environment variables with which to configure the wiki.
Let's talk about these, first:
* `ODDMUSE_STORAGE` is the class handling your storage requirements.
The default is `Storage::File` which stores everything in plain text
files. We'd love to add more!
* `ODDMUSE_WIKI` is the location of your wiki. If you are using
`Storage::File` (the default), then this refers to your wiki
directory. Its default value is `wiki`. That's the same directory
where this `README.md` is.
* `ODDMUSE_MENU` is a comma separated list of pages for the main menu.
The default is `Home, Changes, About`. That also means that none of
the pages in the menu may contain a comma.
### Changes
One page name is special: viewing this page lists recent changes on
the wiki instead of showing the page itself. By default, this page is
called "Changes". It's name is stored in an environment variable:
* `ODDMUSE_CHANGES` is the page which acts as an alias for the
`/changes` route. The default is `Changes`.
This means that you cannot edit the `Changes` page: it's content is
inaccessible as the automatic list of recent changes is displayed
instead.
Don't forget to change the `changes.sp6` template if you change the
name of this page.
Here's an example of how to have a page called "Updates":
1. Set the `ODDMUSE_MENU` environment variable to `Home, Updates, About`. This makes sure that "Updates" shows up in the menu.
2. Set the `ODDMUSE_CHANGES` environment variable to `Updates`. This
makes sure that clicking on the link is the equivalent of visiting
`/changes`.
3. Edit the `changes.sp6` template and replace occurences of "Changes"
with "Updates" in the `title` element and the `h1` element such
that there is no mismatch between the link and the title.
### Resources
The following variables point to directories used to server resources.
* `ODDMUSE_IMAGES`
* `ODDMUSE_CSS`
* `ODDMUSE_TEMPLATES`
* `ODDMUSE_WIKI`
For images, css files and templates, this is how lookup works:
1. If an environment variable with the correct name exists, it's value
is used as the directory. Since the `.cro.yml` file does
that, you can simply run `cro run` and it should find all the
files.
2. If no environment variable exists, the current working dir is
checked for directories with the right names. If they exist, they
are used. This is important when you run `raku -I lib service.pm6`
directly, since that ignores the `.cro.yml` file.
3. If none of the above, the copies in the `resources` folder of the
module itself are used, if you installed Oddmuse via `zef`.
As for the wiki directory: it is created if it doesn't exist. At that
point the `Home.md` page from the module's `resources` folder is
copied so that your wiki comes with at least one page. As this refers
to the `resources` folder, it only works if you installed Oddmuse via
`zef`.
### Images and CSS
Your website needs two directories for the static files:
* `ODDMUSE_IMAGES` is where `logo.png` is. This is used for the
`favicon.ico`. Files from this directory are served as-is. You could
use the logo image in your templates, for example.
* `ODDMUSE_CSS` is there `default.css` is. This is used by the default
templates.
These directories can be shared between various instances of the wiki.
### Templates
This is where the templates are. The templates use the
[Mustache](https://mustache.github.io/) format.
### Wiki
This is where the dynamic content of your wiki is. If you use the
`Storage::File` back end, it contains the following:
* `page` is where the current pages are saved
* `keep` is where older revisions of pages are kept
* `rc.log` is the log file
### Example: Changing the CSS
Here's a simple change to make:
```
mkdir css
cp resources/css/default.css css/
cat - << EOF >> css/default.css
body {
background: black;
color: green;
}
EOF
ODDMUSE_HOST=localhost ODDMUSE_PORT=8000 raku -I lib service.p6
```
This works because now we're not using `cro` to launch the process and
thus `.cro.yml` isn't being used and thus the environment defined in
that file isn't being used. That's why we had to provide our own host
and port, and that's why the modified `default.css` from the local
`css` directory is being used.
Taking it from here should be easy: the `templates` directory and the
`images` directory work just the same.
If you want these changes to take effect and you still want to `cro run`, you need to make changes to the `.cro.yml` file.
### Spam Protection
There is currently a very simple protection scheme in place, using
three pieces of information in three environment variables:
1. `ODDMUSE_QUESTION` is a question
2. `ODDMUSE_ANSWER` are possible answers, comma separated
3. `ODDMUSE_SECRET` is a secret which can be stored in a cookie, which
basically means you should only use alphanumeric ASCII characters:
no spaces, nothing fancy
This is how it works: whenever somebody tries to save a page, we check
if they have answered the question. If they do, they'll have a cookie
holding the secret. If they don't we redirect them to a page where
they must answer the question. If they answer correctly, the cookie
with the secret is set and the page is saved.
As the secret is stored in the cookie, people have to answer the
question whenever they delete their cookies, or whenever they change
browsers.
An example setup might use the following settings, for example:
```
ODDMUSE_QUESTION=Name a colour of the rainbow.
ODDMUSE_ANSWER=red, orange, yellow, green, blue, indigo, violet
ODDMUSE_SECRET=rainbow-unicorn
```
## Hosting Multiple Wikis
Create two empty wiki data directories:
```
mkdir wiki1 wiki2
```
Start the first wiki:
```
ODDMUSE_HOST=localhost ODDMUSE_PORT=9000 ODDMUSE_WIKI=wiki1 raku -Ilib service.p6
```
Start the second wiki:
```
ODDMUSE_HOST=localhost ODDMUSE_PORT=9001 ODDMUSE_WIKI=wiki2 raku -Ilib service.p6
```
Now you can visit both `http://localhost:9000/` and
`http://localhost:9001/` and you'll find two independent wikis.
## Docker
I'm not sure how you would go about building the docker image. Any
help is appreciated.
```
docker build -t edit .
docker run --rm -p 10000:10000 edit
```
|
## traits.md
Traits
Compile-time specification of behavior made easy
In Raku, *traits* are compiler hooks attached to objects and classes that modify their default behavior, functionality or representation. As such compiler hooks, they are defined in compile time, although they can be used in runtime.
Several traits are already defined as part of the language or the Rakudo compiler by using the `trait_mod` keyword. They are listed, and explained, next.
# [`is` trait](#Traits "go to top of document")[§](#The_is_trait "direct link")
```raku
proto trait_mod:<is>(Mu $, |) {*}
```
`is` applies to any kind of scalar object, and can take any number of named or positional arguments. It is the most commonly used trait, and takes the following forms, depending on the type of the first argument.
## [`is` applied to classes.](#Traits "go to top of document")[§](#is_applied_to_classes. "direct link")
The most common form, involving two classes, one that is being defined and the other existing, [defines parenthood](/routine/is). `A is B`, if both are classes, defines A as a subclass of B.
[`is DEPRECATED`](/type/Attribute#trait_is_DEPRECATED) can be applied to classes, Attributes or Routines, marks them as deprecated and issues a message, if provided.
Several instances of `is` are translated directly into attributes for the class they refer to: `rw`, `nativesize`, `ctype`, `unsigned`, `hidden`, `array_type`.
The Uninstantiable representation trait is not so much related to the representation as related to what can be done with a specific class; it effectively prevents the creation of instances of the class in any possible way.
```raku
constant @IMM = <Innie Minnie Moe>;
class don't-instantiate is repr('Uninstantiable') {
my $.counter;
method imm () {
return @IMM[ $.counter++ mod @IMM.elems ];
}
}
say don't-instantiate.imm for ^10;
```
Uninstantiable classes can still be used via their class variables and methods, as above. However, trying to instantiate them this way: `my $do-instantiate = don't-instantiate.new;` will yield the error `You cannot create an instance of this type (don't-instantiate)`.
## [`is repr` and native representations.](#Traits "go to top of document")[§](#is_repr_and_native_representations. "direct link")
Since the `is` trait refers, in general, to the nature of the class or object they are applied to, they are used extensively in [native calls](/language/nativecall) to [specify the representation](/language/nativecall#Specifying_the_native_representation) of the data structures that are going to be handled by the native functions via the `is repr` suffix; at the same time, `is native` is used for the routines that are actually implemented via native functions. These are the representations that can be used:
* CStruct corresponds to a `struct` in the C language. It is a composite data structure which includes different and heterogeneous lower-level data structures; see [this](/language/nativecall#Structs) for examples and further explanations.
* CPPStruct, similarly, correspond to a `struct` in C++. However, this is Rakudo specific for the time being.
* CPointer is a pointer in any of these languages. It is a dynamic data structure that must be instantiated before being used, can be [used](/language/nativecall#Basic_use_of_pointers) for classes whose methods are also native.
* CUnion is going to use the same representation as an `union` in C; see [this](/language/nativecall#CUnions) for an example.
On the other hand, P6opaque is the default representation used for all objects in Raku.
```raku
class Thar {};
say Thar.REPR; # OUTPUT: «P6opaque»
```
The [metaobject protocol](/language/mop) uses it by default for every object and class unless specified otherwise; for that reason, it is in general not necessary unless you are effectively working with that interface.
## [`is` on routines](#Traits "go to top of document")[§](#is_on_routines "direct link")
The `is` trait can be used on the definition of methods and routines to establish [precedence](/language/functions#Precedence) and [associativity](/language/functions#Associativity). They act as a [sub defined using `trait_mod`](/type/Sub#Traits) which take as argument the types and names of the traits that are going to be added. In the case of subroutines, traits would be a way of adding functionality which cuts across class and role hierarchies, or can even be used to add behaviors to independently defined routines.
## [`is implementation-detail`](#Traits "go to top of document")[§](#is_implementation-detail_trait "direct link")
Available as of the 2020.05 release of the Rakudo compiler.
This trait is used by Raku language implementations and module authors to mark particular routines (including methods) as not meant to be a part of public API. While such routines can be found when looked up directly, they will not appear in results of introspection:
```raku
my &do-not-use-routine = CORE::<&DYNAMIC>;
say CORE::.keys.grep(* eq '&DYNAMIC'); # OUTPUT: «()»
```
Such routines are not meant for use by users and their behavior and availability can be changed anytime.
As of the 2021.02 release of the Rakudo compiler, it is also possible to apply the `is implementation-detail` method on classes and roles.
### [method is-implementation-detail](#Traits "go to top of document")[§](#method_is-implementation-detail "direct link")
```raku
method is-implementation-detail(--> True)
```
Applying this trait makes the `is-implementation-detail` method called on [`Code`](/type/Code) to return `True`, thus giving a hint to the user not to use it if they are not willing to maintain this code in case of changes for years to come:
```raku
my &fail-routine = &fail;
unless &fail-routine.is-implementation-detail {
say "&fail is not an implementation detail, can expect backward compatibility";
}
sub PRIVATE-CALCULATION is implementation-detail { #`(Not safe to rely on this) }
if &PRIVATE-CALCULATION.is-implementation-detail {
say "You better not to rely on &PRIVATE-CALCULATION unless you really know what you are doing";
}
```
|
## strdistance.md
class StrDistance
Contains the result of a string transformation.
`StrDistance` objects are used to represent the return of the [string transformation](/language/operators#tr///_in-place_transliteration) operator.
```raku
say (($ = "fold") ~~ tr/old/new/).^name; # OUTPUT: «StrDistance»
```
A `StrDistance` object will stringify to the resulting string after the transformation, and will numify to the distance between the two strings.
```raku
my $str = "fold";
my $str-dist = ($str ~~ tr/old/new/);
say ~$str-dist; # OUTPUT: «fnew»
say +$str-dist; # OUTPUT: «3»
```
# [Methods](#class_StrDistance "go to top of document")[§](#Methods "direct link")
## [method before](#class_StrDistance "go to top of document")[§](#method_before "direct link")
This is actually a class attribute, and called as a method returns the string before the transformation:
```raku
say $str-dist.before; # OUTPUT: «fold»
```
## [method after](#class_StrDistance "go to top of document")[§](#method_after "direct link")
Also a class attribute, returns the string after the transformation:
```raku
say $str-dist.after; # OUTPUT: «fnew»
```
## [method Bool](#class_StrDistance "go to top of document")[§](#method_Bool "direct link")
Returns `True` if `before` is different from `after`.
## [method Numeric](#class_StrDistance "go to top of document")[§](#method_Numeric "direct link")
Returns the distance as a number.
## [method Int](#class_StrDistance "go to top of document")[§](#method_Int "direct link")
```raku
multi method Int(StrDistance:D:)
```
Returns the distance between the string before and after the transformation.
## [method Str](#class_StrDistance "go to top of document")[§](#method_Str "direct link")
```raku
multi method Str(StrDistance:D: --> Str)
```
Returns an `after` string value.
```raku
my $str-dist = ($str ~~ tr/old/new/);
say $str-dist.Str; # OUTPUT: «fnew»
say ~$str-dist; # OUTPUT: «fnew»
```
# [Typegraph](# "go to top of document")[§](#typegraphrelations "direct link")
Type relations for `StrDistance`
raku-type-graph
StrDistance
StrDistance
Cool
Cool
StrDistance->Cool
Mu
Mu
Any
Any
Any->Mu
Cool->Any
[Expand chart above](/assets/typegraphs/StrDistance.svg)
|
## exceptions.md
Exceptions
Using exceptions in Raku
Exceptions in Raku are objects that hold information about errors. An error can be, for example, the unexpected receiving of data or a network connection no longer available, or a missing file. The information that an exception object stores is, for instance, a human-readable message about the error condition, the backtrace of the raising of the error, and so on.
All built-in exceptions inherit from [`Exception`](/type/Exception), which provides some basic behavior, including the storage of a backtrace and an interface for the backtrace printer.
# [*Ad hoc* exceptions](#Exceptions "go to top of document")[§](#Ad_hoc_exceptions "direct link")
Ad hoc exceptions can be used by calling [die](/routine/die) with a description of the error:
```raku
die "oops, something went wrong";
# OUTPUT: «oops, something went wrong in block <unit> at my-script.raku:1»
```
It is worth noting that `die` prints the error message to the standard error `$*ERR`.
# [Typed exceptions](#Exceptions "go to top of document")[§](#Typed_exceptions "direct link")
Typed exceptions provide more information about the error stored within an exception object.
For example, if while executing `.frobnicate` on an object, a needed path `foo/bar` becomes unavailable, then an [`X::IO::DoesNotExist`](/type/X/IO/DoesNotExist) exception can be thrown:
```raku
method frobnicate($path) {
X::IO::DoesNotExist.new(:$path, :trying("frobnicate")).throw
unless $path.IO.e;
# do the actual frobnication
}
```
```raku
frobnicate("foo/bar");
# OUTPUT: «Failed to find 'foo/bar' while trying to do '.frobnicate'
# in block <unit> at my-script.raku:1»
```
Note how the object has provided the backtrace with information about what went wrong. A user of the code can now more easily find and correct the problem.
Instead of calling the `.throw` method on the [`X::IO::DoesNotExist`](/type/X/IO/DoesNotExist) object, one can also use that object as a parameter to `die`:
```raku
die X::IO::DoesNotExist.new(:$path, :trying("frobnicate"));
```
# [Catching exceptions](#Exceptions "go to top of document")[§](#Catching_exceptions "direct link")
It's possible to handle exceptional circumstances by supplying a `CATCH` block:
```raku
CATCH {
when X::IO { $*ERR.say: "some kind of IO exception was caught!" }
}
X::IO::DoesNotExist.new(:$path, :trying("frobnicate")).throw
# OUTPUT: «some kind of IO exception was caught!»
```
Here, we are saying that if any exception of type [`X::IO`](/type/X/IO) occurs, then the message `some kind of IO exception was caught!` will be sent to *stderr*, which is what `$*ERR.say` does, getting displayed on whatever constitutes the standard error device in that moment, which will probably be the console by default.
A `CATCH` block uses smartmatching similar to how `given/when` smartmatches on options, thus it's possible to catch and handle various categories of exceptions inside a `when` block. And it does so because, within the block, `$_` is set to the exception that has been raised.
To handle all exceptions, use a `default` statement. This example prints out almost the same information as the normal backtrace printer; the *dot* methods apply to `$_`, which holds the [`Exception`](/type/Exception) within the `CATCH` block.
```raku
CATCH {
default {
$*ERR.say: .message;
for .backtrace.reverse {
next if .file.starts-with('SETTING::');
next unless .subname;
$*ERR.say: " in block {.subname} at {.file} line {.line}";
}
}
}
```
Note that the match target is a role. To allow user defined exceptions to match in the same manner, they must implement the given role. Just existing in the same namespace will look alike but won't match in a `CATCH` block.
Note that the `CATCH` block semantics apply to the **entire** lexical scope in which it is defined, **regardless** of where it is defined inside that lexical scope. It is therefore advised to put any `CATCH` block at the start of the lexical scope to which they apply so that the casual reader of the code can immediately see that there is something special going on.
## [Exception handlers and enclosing blocks](#Exceptions "go to top of document")[§](#Exception_handlers_and_enclosing_blocks "direct link")
After a CATCH has handled the exception, the block enclosing the `CATCH` block is exited.
In other words, even when the exception is handled successfully, the *rest of the code* in the enclosing block will never be executed.
```raku
die "something went wrong ...";
CATCH {
# will definitely catch all the exception
default { .Str.say; }
}
say "This won't be said."; # but this line will be never reached since
# the enclosing block will be exited immediately
# OUTPUT: «something went wrong ...»
```
Compare with this:
```raku
CATCH {
CATCH {
default { .Str.say; }
}
die "something went wrong ...";
}
say "Hi! I am at the outer block!"; # OUTPUT: «Hi! I am at the outer block!»
```
See [Resuming of exceptions](/language/exceptions#Resuming_of_exceptions), for how to return control back to where the exception originated.
# [`try` blocks](#Exceptions "go to top of document")[§](#try_blocks "direct link")
A `try` block is a normal block which implicitly turns on the [`use fatal` pragma](/language/pragmas#fatal) and includes an implicit `CATCH` block that drops the exception, which means you can use it to contain them. Caught exceptions are stored inside the `$!` variable, which holds a value of type [`Exception`](/type/Exception).
A normal block like this one will simply fail:
```raku
{
my $x = +"a";
say $x.^name;
} # OUTPUT: «Failure»
```
However, a `try` block will contain the exception and put it into the `$!` variable:
```raku
try {
my $x = +"a";
say $x.^name;
}
if $! { say "Something failed!" } # OUTPUT: «Something failed!»
say $!.^name; # OUTPUT: «X::Str::Numeric»
```
Any exception that is thrown in such a block will be caught by a `CATCH` block, either implicit or provided by the user. In the latter case, any unhandled exception will be rethrown. If you choose not to handle the exception, they will be contained by the block.
```raku
try {
die "Tough luck";
say "Not gonna happen";
}
try {
fail "FUBAR";
}
```
In both `try` blocks above, exceptions will be contained within the block, but the `say` statement will not be run. We can handle them, though:
```raku
class E is Exception { method message() { "Just stop already!" } }
try {
E.new.throw; # this will be local
say "This won't be said.";
}
say "I'm alive!";
try {
CATCH {
when X::AdHoc { .Str.say; .resume }
}
die "No, I expect you to DIE Mr. Bond!";
say "I'm immortal.";
E.new.throw;
say "No, you don't!";
}
```
Which would output:
｢text｣ without highlighting
```
```
I'm alive!
No, I expect you to DIE Mr. Bond!
I'm immortal.
Just stop already!
in block <unit> at exception.raku line 21
```
```
Since the `CATCH` block is handling just the [`X::AdHoc`](/type/X/AdHoc) exception thrown by the `die` statement, but not the `E` exception. In the absence of a `CATCH` block, all exceptions will be contained and dropped, as indicated above. `resume` will resume execution right after the exception has been thrown; in this case, in the `die` statement. Please consult the section on [resuming of exceptions](/language/exceptions#Resuming_of_exceptions) for more information on this.
A `try`-block is a normal block and as such treats its last statement as the return value of itself. We can therefore use it as a right-hand side.
```raku
say try { +"99999" } // "oh no"; # OUTPUT: «99999»
say try { +"hello" } // "oh no"; # OUTPUT: «oh no»
```
Try blocks support `else` blocks indirectly by returning the return value of the expression or [`Nil`](/type/Nil) if an exception was thrown.
```raku
with try +"♥" {
say "this is my number: $_"
} else {
say "not my number!"
}
# OUTPUT: «not my number!»
```
`try` can also be used with a statement instead of a block, that is, as a [statement prefix](/language/statement-prefixes#try):
```raku
say try "some-filename.txt".IO.slurp // "sane default";
# OUTPUT: «sane default»
```
What `try` actually causes is, via the `use fatal` pragma, an immediate throw of the exceptions that happen within its scope, but by doing so the `CATCH` block is invoked from the point where the exception is thrown, which defines its scope.
```raku
my $error-code = "333";
sub bad-sub {
die "Something bad happened";
}
try {
my $error-code = "111";
bad-sub;
CATCH {
default {
say "Error $error-code ", .^name, ': ',.Str
}
}
}
# OUTPUT: «Error 111 X::AdHoc: Something bad happened»
```
# [Throwing exceptions](#Exceptions "go to top of document")[§](#Throwing_exceptions "direct link")
Exceptions can be thrown explicitly with the `.throw` method of an [`Exception`](/type/Exception) object.
This example throws an [`X::AdHoc`](/type/X/AdHoc) exception, catches it and allows the code to continue from the point of the exception by calling the `.resume` method.
```raku
{
X::AdHoc.new(:payload<foo>).throw;
"OHAI".say;
CATCH {
when X::AdHoc { .resume }
}
}
"OBAI".say;
# OUTPUT: «OHAIOBAI»
```
If the `CATCH` block doesn't match the exception thrown, then the exception's payload is passed on to the backtrace printing mechanism.
```raku
{
X::AdHoc.new(:payload<foo>).throw;
"OHAI".say;
CATCH { }
}
"OBAI".say;
# OUTPUT: «foo
# in block <unit> at my-script.raku:1»
```
This next example doesn't resume from the point of the exception. Instead, it continues after the enclosing block, since the exception is caught, and then control continues after the `CATCH` block.
```raku
{
X::AdHoc.new(:payload<foo>).throw;
"OHAI".say;
CATCH {
when X::AdHoc { }
}
}
"OBAI".say;
# OUTPUT: «OBAI»
```
`throw` can be viewed as the method form of `die`, just that in this particular case, the sub and method forms of the routine have different names.
# [Resuming of exceptions](#Exceptions "go to top of document")[§](#Resuming_of_exceptions "direct link")
Exceptions interrupt control flow and divert it away from the statement following the statement that threw it. Any exception handled by the user can be resumed and control flow will continue with the statement following the statement that threw the exception. To do so, call the method `.resume` on the exception object.
```raku
CATCH { when X::AdHoc { .resume } } # this is step 2
die "We leave control after this."; # this is step 1
say "We have continued with control flow."; # this is step 3
```
Resuming will occur right after the statement that has caused the exception, and in the innermost call frame:
```raku
sub bad-sub {
die "Something bad happened";
return "not returning";
}
{
my $return = bad-sub;
say "Returned $return";
CATCH {
default {
say "Error ", .^name, ': ',.Str;
$return = '0';
.resume;
}
}
}
# OUTPUT:
# Error X::AdHoc: Something bad happened
# Returned not returning
```
In this case, `.resume` is getting to the `return` statement that happens right after the `die` statement. Please note that the assignment to `$return` is taking no effect, since the `CATCH` statement is happening *inside* the call to `bad-sub`, which, via the `return` statement, assigns the `not returning` value to it.
# [Uncaught exceptions](#Exceptions "go to top of document")[§](#Uncaught_exceptions "direct link")
If an exception is thrown and not caught, it causes the program to exit with a non-zero status code, and typically prints a message to the standard error stream of the program. This message is obtained by calling the `gist` method on the exception object. You can use this to suppress the default behavior of printing a backtrace along with the message:
```raku
class X::WithoutLineNumber is X::AdHoc {
multi method gist(X::WithoutLineNumber:D:) {
$.payload
}
}
die X::WithoutLineNumber.new(payload => "message")
# prints "message\n" to $*ERR and exits, no backtrace
```
# [Control exceptions](#Exceptions "go to top of document")[§](#Control_exceptions "direct link")
Control exceptions are raised when throwing an Exception which does the [`X::Control`](/type/X/Control) role (since Rakudo 2019.03). They are usually thrown by certain [keywords](/language/phasers#CONTROL) and are handled either automatically or by the appropriate [phaser](/language/phasers#Loop_phasers). Any unhandled control exception is converted to a normal exception.
```raku
{ return; CATCH { default { $*ERR.say: .^name, ': ', .Str } } }
# OUTPUT: «X::ControlFlow::Return: Attempt to return outside of any Routine»
# was CX::Return
```
|
## dist_zef-melezhik-SparrowCI-20--20super-20fun-20and-20flexible-20CI-20system-20with-20many-20programming-20languages-20support.md
[](https://ci.sparrowhub.io)
# SparrowCI
SparrowCI - super fun and flexible CI system with many programming languages support.
## Why yet another pipeline DSL?
Read [why?](docs/why.md) manifest.
## Quick start
See [quickstart.md](docs/quickstart.md) document.
## DAG of tasks
See [dag.md](docs/dag.md) document to understand the main idea of SparrowCI flow.
## Deep dive
See [dsl.md](docs/dsl.md) document for a full SparrowCI pipelines tutorial.
## Environment variables
See [variables.md](docs/variables.md) document.
## Self-hosted deployment
See [selfhosted.md](docs/selfhosted.md) document.
## Development
See [development.md](docs/development.md) document.
## External systems integration
See [reporters.md](docs/reporters.md) document.
# Thanks to
God and Jesus Christ who inspires me
|
## dist_github-jaldhar-Algorithm-DawkinsWeasel.md
# NAME
Algorithm::DawkinsWeasel - An Illustration of Cumulative Selection
# SYNOPSIS
```
use Algorithm::DawkinsWeasel;
my $weasel = Algorithm::DawkinsWeasel.new(
target-phrase => 'METHINKS IT IS LIKE A WEASEL',
mutation-threshold => 0.05,
copies => 100,
);
for $weasel.evolution {
say .count.fmt('%04d '), .current-phrase, ' [', .hi-score, ']';
}
```
# DESCRIPTION
Algorithm::DawkinsWeasel is a simple model illustrating the idea of cumulative
selection in evolution.
The original form of it looked like this:
1. Start with a random string of 28 characters.
2. Make 100 copies of this string, with a 5% chance per character of that
character being replaced with a random character.
3. Compare each new string with "METHINKS IT IS LIKE A WEASEL", and give
each a score (the number of letters in the string that are correct and
in the correct position).
4. If any of the new strings has a perfect score (== 28), halt.
5. Otherwise, take the highest scoring string, and go to step 2
This module parametrizes the target string, mutation threshold, and number of
copies per round.
# INSTALLATION
With a normal rakudo installation, you should have available one or
both of the installer tools:
* `zef`
* `panda`
`zef` is becoming the preferred tool because of more features
(including an uninstall function) and more active development, but
either tool should work fine for a first installation of a desired
module. We'll use `zef` for the rest of the examples.
```
zef install Algorithm::DawkinsWeasel
```
If the attempt shows that the module isn't found or available, ensure
your installer is current:
```
zef update
```
If you want to use the latest version in the git repository (or it's
not available in the Perl 6 ecosystem), clone it and then install it
from its local directory. Here we assume the module is on Github in
location "https://github.com/jaldhar/Algorithm-DawkinsWeasel", but use
the Github clone instructions for the desired module. (Note the
repository name is usually not the exact name of the module as used in
Perl 6.)
```
git clone https://github.com/jaldhar/Algorithm-DawkinsWeasel.git
cd /path/to/cloned/repository/directory
zef install .
```
# AUTHOR
Jaldhar H. Vyas [jaldhar@braincells.com](mailto:jaldhar@braincells.com)
# COPYRIGHT AND LICENSE
Copyright (C) 2017, Consolidated Braincells Inc. All rights reserved.
This distribution is free software; you can redistribute it and/or modify it
under the terms of either:
a) the GNU General Public License as published by the Free Software
Foundation; either version 2, or (at your option) any later version, or
b) the Artistic License version 2.0.
The full text of the license can be found in the LICENSE file included
with this distribution.
|
## dist_zef-tbrowder-Geo-Location.md
[](https://github.com/tbrowder/Geo-Location/actions) [](https://github.com/tbrowder/Geo-Location/actions) [](https://github.com/tbrowder/Geo-Location/actions)
# NAME
`Geo::Location` - Provides location data for astronomical and other programs
# SYNOPSIS
Use the default location:
```
$ raku
> use Geo::Location;
> my $loc = Location.new; # note no arguments entered here
> say $loc.name;
Gulf Breeze, FL, USA
> say $loc.location;
lat: 30.485092, lon: -86.4376157
say $loc.lat;
30.485092
say $loc.lon;
-86.4376157
```
# DESCRIPTION
**Geo::Location** Allows the user to define a geographical location for easy use either by manual entry, from a JSON description, or an environment variable (`GEO_LOCATION`).
For now one must enter latitude and longitude using signed decimal numbers. One easy way to find those for a location is to use Google Maps (on a PC) and drop a location pin with its point at the place of interest. Then select the pin, right-click, and see the lat/lon on the first line of data. (I have had some success also with doing that on an iPad, but it's a bit trickier for my tastes, hence my use of a PC for real mapping uses.)
Note the object has only two required parameters ($lat, $lon), but there are nine other attributes available. See them listed below.
### Class construction
Use the manual entry:
```
my $loc = Geo::Location.new: :lat(-36.23), :lon(+12);
```
Use a JSON description:
```
my $json = q:to/HERE/;
{
"name" : "Foo Town",
"lat" : 35.267,
"lon" : -42.3
}
HERE
my $loc = Geo::Location.new: :$json;
```
Use an environment variable:
Define desired attributes just like a manual entry but without the colons. Use double quotes on the entire value and single quotes inside, or the reverse, as desired. Note also strings without spaces do not require quotes inside the parentheses. Note also this is only used when (1) no manual or json methods are used and (2) a valid `GEO_LOCATION` environment variable is defined in the using environment.
```
$ export GEO_LOCATION="lat(42.4),lon(13.6),name('Baz Beach')";
```
### Class attributes
There are eleven total public attributes in the class.
* city
* country
typically a two-character ISO code
* county
* id
use as unique reference in a collection
* lat
* lon
* name
a convenient display name
* notes
* region
**EU**, etc., multi-country area with DST rules
* state
typically a two-letter ISO code, for example, a US state
* timezone
use as a reference time zone abbreviation for use with module **DateTime::US**
### Class methods
In addition to the methods provided for the public attributes listed above, the following added methods provide some other ways of showing object data.
* **lat-dms**(--> Str) {...}
Returns the latitude in DMS format
* **lon-dms**(--> Str) {...}
Returns the longitude in DMS format
* **riseset-format**(:bare --> Str) {...}
Returns the format required by the Perl programs accompanying CPAN Perl module **Astro::Montenbruck** (in this module the format will also be referred to as '**RST**'):
```
./script/riseset.pl --place=30N29 86W26 --twilight=civil
```
Note that Perl module's convention for the sign of East longitude is negative instead of positive for decimal entries, so it is important to use the provided RST format to avoid longitude errors.
* **lat-rst**(--> Str) {...}
Returns the latitude in RST format
* **lon-rst**(--> Str) {...}
Returns the longitude in RST format
* **location**(:$format = 'decimal', :bare --> Str) {
Returns the location in a single string in the specified format. For example:
In default decimal:
```
say $loc.location;
lat: 30.485092, lon: -86.4376157
say $loc.location(:bare);
30.485092 -86.4376157
```
Or in DMS:
```
say $loc.location(:format('dms'));
lat: N30d29m6s, lon: W86d26m15s
say $loc.location(:format('dms'), :bare);
N30d29m6s W86d26m15s
```
Or in RST:
```
say $loc.location(:format('rst'));
lat: 30N29, lon: 86W26
say $loc.location(:format('rst'), :bare);
30N29 86W26
```
# To Do
* Allow other forms of lat/lon entry besides decimal
* Provide more methods for astronomical use
* Prove enums for use with argument entry
# AUTHOR
Tom Browder `tbrowder@acm.org`
# COPYRIGHT AND LICENSE
© 2021-2024 Tom Browder
This library is free software; you may redistribute it or modify it under the Artistic License 2.0.
|
## dist_cpan-JNTHN-Cro-HTTP.md
# Cro::HTTP Build Status
This is part of the Cro libraries for implementing services and distributed
systems in Raku. See the [Cro website](http://cro.services/) for further
information and documentation.
|
## dist_zef-akiym-JSON-Hjson.md
[](https://github.com/akiym/JSON-Hjson/actions)
# NAME
JSON::Hjson - Human JSON (Hjson) deserializer
# SYNOPSIS
```
use JSON::Hjson;
my $text = q:to'...';
{
// specify delay in
// seconds
delay: 1
message: wake up!
}
...
say from-hjson($text).raku;
```
# DESCRIPTION
JSON::Hjson implements Human JSON (Hjson) in Raku grammar.
# SEE ALSO
JSON::Tiny
<https://hjson.org/rfc.html>
# AUTHOR
Takumi Akiyama [t.akiym@gmail.com](mailto:t.akiym@gmail.com)
# COPYRIGHT AND LICENSE
Copyright 2016 Takumi Akiyama
This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.
|
## dist_github-ugexe-CompUnit-Repository-Github.md
## CompUnit::Repository::Github
Load modules directly from the Github API over http. Fuck it.
## Synopsis
```
BEGIN %*ENV<GITHUB_ACCESS_TOKEN> = "..."; # optional, but useful due to api rate limiting
use CompUnit::Repository::Github;
use lib "CompUnit::Repository::Github#user<ugexe>#repo<Raku-PathTools>#branch<main>#/";
require ::("PathTools") <&ls>;
say &ls($*CWD);
```
See: [tests](https://github.com/ugexe/Raku-CompUnit--Repository--Github/blob/main/t)
|
## dist_cpan-JMERELO-Perl6-Ecosystem.md
[](https://travis-ci.org/JJ/p6-river)
# NAME
Perl6::Ecosystem - Obtains information from Perl6 modules in the ecosystem
# SYNOPSIS
```
use Perl::Ecosystem;
my $eco = Perl6::Ecosystem.new;
say $eco.modules;
say $eco.depended;
say $eco.depends-on;
```
# DESCRIPTION
A tool to analyze the Perl 6 ecosystem by downloading all modules and finding out how they depend on each other.
# METHODS
## method new( )
Creates the object, downloading and filling it with information. Error output goes to `/tmp/perl6-eco-err.txt`
## method modules
Returns a `hash` with module names, dependencies and URLs.
## method depended
Returns a `hash` with module names and the number of other modules it depends on.
## method depends-on
Returns a `hash` with module names and its dependencies.
## method river-scores --> Hash
Computes the "river-score" by looking at all dependency chains and giving a score according to the position. That is, if there's this dependenci chain
```
Foo → Bar → Baz
```
Foo will have a 0 score for appearing in the first position, up to Baz which will have score equal to 2. The total score of every module is computed by adding all scores.
# SEE ALSO
[Perl6 module ecosystem](https://modules.perl6.org).
# KNOWN BUGS
It chokes on circular references. Right now they are blacklisted.
# AUTHOR
Alex Daniel, JJ Merelo [jjmerelo@gmail.com](mailto:jjmerelo@gmail.com)
# COPYRIGHT AND LICENSE
Copyright 2018 Alex Daniel, JJ Merelo
This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.
|
## dist_zef-dwarring-CSS-Module.md
[[Raku CSS Project]](https://css-raku.github.io)
/ [[CSS-Module]](https://css-raku.github.io/CSS-Module-raku)
# CSS::Module
```
# Parse a sample stylesheet as CSS 2.1. Dump the AST.
use v6;
use CSS::Module::CSS21;
my $css = 'h1 { color: orange; text-align: center }';
my $module = CSS::Module::CSS21.module;
my $actions = $module.actions.new;
$module.grammar.parse( $css, :$actions);
say $/.ast.raku;
```
CSS::Module is a set of Raku classes for parsing and manipulation of CSS Levels 1, 2.1 and 3, and SVG.
It contains modules `CSS::Module::CSS1`, `CSS::Module::CSS21` and `CSS::Module::CSS3` for CSS levels 1.0, 2.1 and 3.0, along with `CSS::Module::SVG`, which is a CSS3 extension for [styling SVG](https://www.w3.org/TR/SVG2/styling.html).
Each of these classes has a `module` method which produces an object that encapsulates grammars, actions
and property metadata. It has a`property-metadata` method that can be used to introspect properties. For example
```
% raku -M CSS::Module::CSS3 -e'say CSS::Module::CSS3.module.property-metadata<azimuth>.raku'
{:default("center"), :inherit, :synopsis("<angle> | [[ left-side | far-left | left | center-left | center | center-right | right | far-right | right-side ] || behind ] | leftwards | rightwards")}
```
Note: `CSS::Module::CSS3.module` is composed from the following grammars.
* `CSS::Module::CSS3::Colors` - CSS 3.0 Colors (@color-profile)
* `CSS::Module::CSS3::Fonts` - CSS 3.0 Fonts (@font-face)
* `CSS::Module::CSS3::Selectors` - CSS 3.0 Selectors
* `CSS::Module::CSS3::Namespaces` - CSS 3.0 Namespace (@namespace)
* `CSS::Module::CSS3::Media` - CSS 3.0 Media (@media)
* `CSS::Module::CSS3::PagedMedia` - CSS 3.0 Paged Media (@page)
* `CSS::ModuleX::CSS21` - the full set of CSS21 properties
This corresponds to the sub-modules described in [CSS Snapshot 2010](http://www.w3.org/TR/2011/NOTE-css-2010-20110512/).
## Installation
You can use the Raku `zef` module installer to test and install `CSS::Module`:
```
% zef install CSS::Module
```
## Examples
* parse a stylesheet using the CSS2.1 grammar:
% raku -MCSS::Module::CSS21 -e"say CSS::Module::CSS21.parse('h1 {margin:2pt; color: blue}')"
* compile a CSS2.1 stylesheet to an AST, using the module interface:
```
use v6;
use CSS::Module::CSS21;
my $css = 'H1 { color: blue; foo: bar; background-color: zzz }';
my $module = CSS::Module::CSS21.module;
my $grammar = $module.grammar;
my $actions = $module.actions.new;
my $p = $grammar.parse($css, :$actions);
note $_ for $actions.warnings;
say "declaration: " ~ $p.ast[0]<ruleset><declarations>.raku;
# output:
# unknown property: foo - declaration dropped
# usage background-color: <color> | transparent | inherit
# declaration: {"color" => {"expr" => [{"rgb" => [{"num" => 0}, {"num" => 0}, {"num" => 255}]}]}
```
* parse an individual `azimuth` property expression via the module interface:
```
use v6;
use CSS::Module::CSS21;
my $ast = CSS::Module::CSS21.module.parse-property('azimuth', 'center-left behind');
```
* Composition: A secondary aim is mixin style module composition. For example to create a module MyCSS3Subset::CSS3 comprising CSS2.1 properties + CSS3 Selectors + CSS3 Colors:
```
use v6;
use CSS::Module;
use CSS::Module::CSS21::Actions;
use CSS::Module::CSS21;
use CSS::Module::CSS3::Selectors;
use CSS::Module::CSS3::Colors;
use CSS::Module::CSS3::_Base;
class MyCSS3Subset::Actions
is CSS::Module::CSS3::Selectors::Actions
is CSS::Module::CSS3::Colors::Actions
is CSS::ModuleX::CSS21::Actions
is CSS::Module::CSS3::_Base::Actions {
};
grammar MyCSS3Subset::CSS3
is CSS::Module::CSS3::Selectors
is CSS::Module::CSS3::Colors
is CSS::ModuleX::CSS21
is CSS::Module::CSS3::_Base {
#| a minimal module definition: grammar + actions
method module {
state $this //= CSS::Module.new(
:name<my-css3-subset>,
:grammar($?CLASS),
:actions(MyCSS3Subset::Actions) );
}
};
```
## Property Definitions
Property definitions are built from the sources in the `src` directory using the CSS::Specification tools. These implement the [W3C Property Definition Syntax](https://developer.mozilla.org/en-US/docs/Web/CSS/Value_definition_syntax).
Generated modules are written under the `gen/lib` directory.
For example [CSS::Module:CSS1::Spec::Grammar](gen/lib/CSS/Module/CSS1/Spec/Grammar.pm), [CSS::Module:CSS1::Spec::Actions](gen/lib/CSS/Module/CSS1/Spec/Actions.pm) and [CSS::Module:CSS1::Spec::Interface](gen/lib/CSS/Module/CSS1/Spec/Interface.pm) are generated from <etc/css1-properties.txt>.
See `make-modules.pl`.
## Actions Options
* **`:lax`** Don't warn about, or discard, unknown properties, sub-rules. Pass back the elements with a classification
of unknown. E.g.
```
my $module = CSS::Module::CSS21.module;
my $grammar = $module.grammar;
my $actions = $module.actions.new( :lax );
say $grammar.parse('{bad-prop: 12mm}', :$actions, :rule<declarations>).ast.raku;
# output {"property:unknown" => {:expr[{ :mm(12) }], :ident<bad-prop>}}
say $grammar.parse('{ @guff {color:red} }', :$actions, :rule<declarations>).ast.raku;
# output: {"margin-rule:unknown" => { :declarations[ { :ident<color>,
:expr[ { :rgb[ { :num(255) }, { :num(0) }, { :num(0) } ] } ] } ],
:at-keyw<guff> } }
```
`lax` mode likewise returns quantities with unknown dimensions:
```
say $grammar.parse('{margin: 12mm .1furlongs}', :$actions, :rule<declarations>).ast.raku;
# output {"property" => {:expr[{ :mm(12) }, { :num(0.12), "units:unknown" => <furlongs>}], :ident<margin>}}
```
## Custom Properties
Properties may be added, or overriden via an `:%extensions` option to the `new()` method.
```
subset MyAlignment of Str where 'left'|'middle'|'right';
sub coerce(MyAlignment:D $keyw --> Pair) { :$keyw }
my %extensions = %(
'-my-align' => %(:synopsis("left | middle | right"), :default<middle>, :&coerce),
'-my-misc' => %(), # can hold any value
);
my $module = CSS::Module::CSS3.module: :%extensions;
say $module.property-metadata<-my-align>.raku;
```
## See Also
* [CSS::Properties](https://css-raku.github.io/CSS-Properties-raku) - property-set manipulation module
* [CSS::Specification](https://css-raku.github.io/CSS-Specification-raku) - property definition syntax
* [CSS::Grammar](https://css-raku.github.io/CSS-Grammar-raku) - base grammars
* [CSS::Writer](https://css-raku.github.io/CSS-Writer-raku) - AST reserializer
## References
* CSS Snapshot 2010 - <http://www.w3.org/TR/2011/NOTE-css-2010-20110512/>
* CSS1 - <http://www.w3.org/TR/2008/REC-CSS1-20080411/#css1-properties>
* CSS21 - <http://www.w3.org/TR/2011/REC-CSS2-20110607/propidx.html>
* CSS3
* CSS Color Module Level 3 - <http://www.w3.org/TR/2011/REC-css3-color-20110607/>
* CSS Fonts Module Level 3 - <http://www.w3.org/TR/2013/WD-css3-fonts-20130212/>
* CSS3 Namespaces Module - <http://www.w3.org/TR/2011/REC-css3-namespace-20110929/>
* CSS3 Media Query Extensions - <http://www.w3.org/TR/2012/REC-css3-mediaqueries-20120619/>
* CSS3 Module: Paged Media - <http://www.w3.org/TR/2006/WD-css3-page-20061010/>
* CSS Selectors Module Level 3 - <http://www.w3.org/TR/2011/REC-css3-selectors-20110929/>
* SVG - <https://www.w3.org/TR/SVG2/styling.html> <https://www.w3.org/TR/SVG/propidx.html>
|
## dist_github-grondilu-PBKDF2.md
[](https://sparky.sparrowhub.io)
# pbkdf2-raku
PBKDF2 in pure raku. Speed will mostly depend on the pseudo-random function used.
## Synopsis
```
use PBKDF2;
use Digest::MD5;
say pbkdf2 "password",
:salt("salt"),
:prf(&md5 ∘ &[~]),
:c(10),
:dkLen(32);
```
|
## dist_zef-ingy-YAMLScript.md
# YAMLScript
Program in YAML — Code is Data
## Synopsis
```
#!/usr/bin/env ys-0
defn main(name='world'):
say: "Hello, $name!"
```
## Description
YAMLScript is a functional programming language with a stylized YAML syntax.
YAMLScript can be used for:
* Writing new programs and applications
* Run with `ys file.ys`
* Or compile to binary executable with `ys -C file.ys`
* Enhancing ordinary YAML files with new functional magics
* Import parts of other YAML files to any node
* String interpolation including function calls
* Any other functionality you can dream up!
* Writing reusable shared libraries
* High level code instead of C
* Bindable to almost any programming language
YAMLScript should be a drop-in replacement for your YAML loader!
Most existing YAML files are already valid YAMLScript files.
This means that YAMLScript works as a normal YAML loader, but can also evaluate
functional expressions if asked to.
Under the hood, YAMLScript code compiles to the Clojure programming language.
This makes YAMLScript a complete functional programming language right out of
the box.
Even though YAMLScript compiles to Clojure, and Clojure compiles to Java, there
is no dependency on Java or the JVM.
YAMLScript is compiled to a native shared library (`libyamlscript.so`) that can
be used by any programming language that can load shared libraries.
To see the Clojure code that YAMLScript compiles to, you can use the YAMLScript
command line utility, `ys`, to run:
```
$ ys --compile file.ys
```
## Raku Usage
File `prog.raku`:
```
use YAMLScript;
my $program = slurp 'file.ys';
my YAMLScript $ys .= new;
say $ys.load($program);
```
File `file.ys`:
```
!YS-v0:
name =: "World"
foo: [1, 2, ! inc(41)]
bar:: load("other.yaml")
baz:: "Hello, $name!"
```
File `other.yaml`:
```
oh: Hello
```
Run:
```
$ raku prog.raku
{bar => {oh => Hello}, baz => Hello, World!, foo => [1 2 42]}
```
## Installation
You can install this module like any other Raku module:
```
zef install YAMLScript
```
but you will need to have a system install of `libyamlscript.so`.
One simple way to do that is with:
```
curl https://yamlscript.org/install | bash
```
> Note: The above command will install the latest version of the YAMLScript
> command line utility, `ys`, and the shared library, `libyamlscript.so`, into
> `~/local/bin` and `~/.local/lib` respectively.
See <https://github.com/yaml/yamlscript?#installing-yamlscript> for more info.
## See Also
* [The YAMLScript Web Site](https://yamlscript.org)
* [The YAMLScript Blog](https://yamlscript.org/blog)
* [The YAMLScript Source Code](https://github.com/yaml/yamlscript)
* [YAML](https://yaml.org)
* [Clojure](https://clojure.org)
## Authors
* [Ingy döt Net](https://github.com/ingydotnet)
* [tony-o](https://github.com/tony-o)
## License & Copyright
Copyright 2022-2025 Ingy döt Net [ingy@ingy.net](mailto:ingy@ingy.net)
This project is licensed under the terms of the `MIT` license.
See [LICENSE](https://github.com/yaml/yamlscript/blob/main/License) for
more details.
|
## dist_zef-lizmat-String-Color.md
[](https://github.com/lizmat/String-Color/actions) [](https://github.com/lizmat/String-Color/actions) [](https://github.com/lizmat/String-Color/actions)
# NAME
String::Color - map strings to a color code
# SYNOPSIS
```
use String::Color;
use Randomcolor; # some module for randomly generating colors
my $sc = String::Color.new(
generator => { Randomcolor.new.list.head },
cleaner => { .lc }, # optionally provide own cleaning logic
colors => %colors-so-far, # optionally start with given set
);
my @added = $sc.add(@nicks); # add mapping for strings in @nicks
my %colors := $sc.Map; # set up Map with color mappings so far
say "$color is already used"
if $sc.known($color); # check if a color is used already
```
# DESCRIPTION
String::Color provides a class and logic to map strings to a (random) color code. It does so by matching the cleaned version of a string.
The way a color is generated, is determined by the required `generator` named argument: it should provice a `Callable` that will take a cleaned string, and return a color for it.
The way a string is cleaned, can be specified with the optional `cleaner` named argument: it should provide a `Callable` that will take the string, and return a cleaned version of it. By default, the cleaning logic will remove any non-alpha characters, and lowercase the resulting string.
Strings can be continuously added by calling the `add` method. The current state can be obtained with the `Map` method. The `known` method can be used to see whether a color is already being used or not.
Note that colors are described as strings. In whichever format you would like. Technically, this module could be used to match strings to other strings that would not necessarily correspond to colors. But that's entirely up to the fantasy of the user of this module.
Also note that by e.g. writing out the `Map` of a `String::Color` object as e.g. **JSON** to disk, and then later use that in the `colors` argument to `new`, would effectively make the mapping persistent.
Finally, even though this may look like a normal hash, but all operations are thread safe (although results may be out of date).
# CLASS METHODS
## new
```
my $sc = String::Color.new(
generator => -> $string {
$string eq 'liz'
?? "ff0000"
!! RandomColor.new.list.head
},
cleaner => { .lc }, # optionally provide own cleaning logic
colors => %colors-so-far, # optionally start with given set
);
```
The `new` class method takes two named arguments.
### :cleaner
The `cleaner` named argument allows one to specify a `Callable` which is supposed to take a string, and return a cleaned version of the string. By default, a cleaner that will remove all non-alpha characters and return the resulting string in lowercase, will be used.
### :colors
The `colors` named argument allows one to specify a `Hash` / `Map` with colors that have been assigned to strings so far. Only the empty string mapping to the empty string will be assumed, if not specified.
### :generator
The `generator` named argument specifies a `Callable` that will be called to generate a colors for the associated string (which gets passed to the `Callable`). It **must** be specified.
# INSTANCE METHODS
## add
```
my @added = $sc.add(@strings);
```
The `add` instance method allows adding of strings to the colors mapping. It takes a list of strings as the positional argument. It returns a list of strings that were actually added (in the order they were added).
## aliases
```
my @aliases = $sc.aliases($string);
```
The `aliases` instance method returns a sorted list of strings that are considered aliases of the given string, because they share the same cleaned string.
## cleaned
```
.say for $sc.cleaned;
```
The `cleaned` instance method returns the cleaned strings in the same order as `strings`.
## colors
```
say "colors assigned:";
.say for $sc.colors.unique;
```
The `colors` instance method returns the colors in the same order as `strings`.
## elems
```
say "$sc.elems() mappings so far";
```
The `elems` instance method returns the number of mappings.
## known
```
say "$color is already used"
if $sc.known($color); # check if a color is used already
```
The `known` instance method takes a single string for color, and returns whether that color is already in use or not.
## Map
```
my %colors := $sc.Map; # create simple Associative interface
```
The `Map` instance method returns the state of the mapping as a `Map` object, which can be bound to create an `Associative` interface. Or it can be used to create a persistent version of the mapping.
## strings
```
say "strings mapped:";
.say for $sc.strings;
```
The `strings` instance method returns the strings.
# AUTHOR
Elizabeth Mattijsen [liz@raku.rocks](mailto:liz@raku.rocks)
Source can be located at: <https://github.com/lizmat/String-Color> . Comments and Pull Requests are welcome.
If you like this module, or what I'm doing more generally, committing to a [small sponsorship](https://github.com/sponsors/lizmat/) would mean a great deal to me!
# COPYRIGHT AND LICENSE
Copyright 2021, 2024, 2025 Elizabeth Mattijsen
This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.
|
## dist_zef-antononcube-UML-Translators.md
# Raku UML::Translators
## In brief
This repository is for a Raku package for the translations of code into
[Unified Modeling Language (UML)](https://en.wikipedia.org/wiki/Unified_Modeling_Language)
specifications and vice versa.
Currently, the package only translates Object-Oriented Programming (OOP) Raku code into:
* The Domain Specific Language (DSL) of [Mermaid-JS](https://mermaid-js.github.io/mermaid/)
* The DSL of [PlantUML](https://plantuml.com)
* Argument specification of the UML class diagram function [`UMLClassGraph`](https://github.com/antononcube/MathematicaForPrediction/blob/master/Misc/UMLDiagramGeneration.m)
of the Mathematica / Wolfram Language (WL) package [AAp1]
See [AA2] for usage examples of both PlantUML and `UMLClassGraph` in Mathematica.
**Remark:** The package provides Command Line Interface (CLI) script.
**Remark:** (Currently) the development of PlantUML is more robust and complete than that of Mermaid-JS.
Hence, workflow-wise, using this package to generate PlantUML specs would produce (on average) best results.
### Future plans
A fully fledged version of this package would translate:
* C++, Java, Kotlin, or Raku code into UML specs
* UML specs into C++, Java, Kotlin, or Raku code
Currently, only UML specs are generated to PlantUML's DSL and a much poorer WL DSL.
Ideally, subsequent versions of this package would be able to use UML specifications
encoded in XML and JSON.
---
## Installation
### From zef's ecosystem
```
zef install UML::Translators
```
### From GitHub
```
zef install https://github.com/antononcube/Raku-UML-Translators.git
```
---
## Command Line Interface
The package provides the CLI script `to-uml-spec`. Here is its usage message:
```
to-uml-spec --help
```
```
# Usage:
# to-uml-spec <packageName> [--type=<Str>] [-I=<Str>] [--attributes] [--methods] [--concise-grammar-classes] [--format=<Str>] [--plot] [--jar=<Str>] [--viewer=<Str>] -- Make a UML diagram for a specified package.
#
# <packageName> Package name.
# --type=<Str> Type of the UML diagram. [default: 'class']
# -I=<Str> Using include path to find libraries. [default: '']
# --attributes Should the class attributes be included in the UML diagrams or not? [default: True]
# --methods Should the class methods be included in the UML diagrams or not? [default: True]
# --concise-grammar-classes Should grammar classes be shortened or not? [default: True]
# --format=<Str> Format of the output, one of 'Mermaid', 'MermaidJS', 'Plant', 'PlantUML', 'WL', 'WLUML', or 'Whatever'. [default: 'PlantUML']
# --plot Should the result be plotted or not? [default: False]
# --jar=<Str> JAR file to use if --plot. If --jar is an empty string then PLANTUMLJAR and PLANTUML_JAR are attempted. [default: '']
# --viewer=<Str> Image viewer program to use if --plot. If --viewer is an empty string then open is used on macOS and xdg-open on Linux. [default: '']
```
### Usage examples
Generate PlantUML spec for the Raku package
["ML::Clustering"](https://raku.land/zef:antononcube/ML::Clustering):
```
to-uml-spec --/methods --/attributes "ML::Clustering"
```
```
# @startuml
# class "find-clusters" <<routine>> {
# }
# "find-clusters" --|> Routine
# "find-clusters" --|> Block
# "find-clusters" --|> Code
# "find-clusters" --|> Callable
#
#
# class "k-means" <<routine>> {
# }
# "k-means" --|> Routine
# "k-means" --|> Block
# "k-means" --|> Code
# "k-means" --|> Callable
#
#
# class ML::Clustering::KMeans {
# }
# ML::Clustering::KMeans --|> ML::Clustering::DistanceFunctions
#
#
# class ML::Clustering::DistanceFunctions <<role>> {
# }
#
#
# @enduml
```
With this shell command we generate a Plant UML spec for the package
["Chemistry::Stoichiometry"](https://raku.land/cpan:ANTONOV/Chemistry::Stoichiometry)
and create the UML diagram image with a local PlantUML JAR file (downloaded from [PUML1]):
```
to-uml-spec --/methods --/attributes 'Chemistry::Stoichiometry' | java -jar ~/Downloads/plantuml-1.2022.5.jar -pipe -tjpg > /tmp/myuml.jpg
```
---
## Raku session
### UML for ad hoc classes
Here we generate a PlantUML spec:
```
use UML::Translators;
module MyPackageClass {
role A { method a1 {} }
role B { method b1 {} }
class C does A { has $!c-var; method c1 {} }
class D does B is C { has $!d-var; method d1 {} }
}
to-uml-spec('MyPackageClass')
```
```
# @startuml
# class MyPackageClass::C {
# {field} $!c-var
# {method} BUILDALL
# {method} a1
# {method} c1
# }
# MyPackageClass::C --|> MyPackageClass::A
#
#
# class MyPackageClass::D {
# {field} $!c-var
# {field} $!d-var
# {method} BUILDALL
# {method} b1
# {method} d1
# }
# MyPackageClass::D --|> MyPackageClass::C
# MyPackageClass::D --|> MyPackageClass::A
# MyPackageClass::D --|> MyPackageClass::B
#
#
# class MyPackageClass::B <<role>> {
# {method} b1
# }
#
#
# class MyPackageClass::A <<role>> {
# {method} a1
# }
#
#
# @enduml
```
Here we generate a MermaidJS spec:
```
to-uml-spec('MyPackageClass', format => 'mermaid')
```
```
classDiagram
class MyPackageClass_C {
+$!c-var
+BUILDALL()
+a1()
+c1()
}
MyPackageClass_C --|> MyPackageClass_A
class MyPackageClass_D {
+$!c-var
+$!d-var
+BUILDALL()
+b1()
+d1()
}
MyPackageClass_D --|> MyPackageClass_C
MyPackageClass_D --|> MyPackageClass_A
MyPackageClass_D --|> MyPackageClass_B
class MyPackageClass_B {
<<role>>
+b1()
}
class MyPackageClass_A {
<<role>>
+a1()
}
```
### UML for packages
Get PlantUML code for the package
['Chemistry::Stoichiometry'](https://raku.land/cpan:ANTONOV/Chemistry::Stoichiometry):
```
say to-uml-spec('Chemistry::Stoichiometry'):!methods:!attributes
```
```
# @startuml
# class Chemistry::Stoichiometry::ResourceAccess {
# }
#
#
# class Chemistry::Stoichiometry::Grammar <<grammar>> {
# }
# Chemistry::Stoichiometry::Grammar --|> Grammar
# Chemistry::Stoichiometry::Grammar --|> Match
# Chemistry::Stoichiometry::Grammar --|> Capture
# Chemistry::Stoichiometry::Grammar --|> Chemistry::Stoichiometry::Grammar::ChemicalElement
# Chemistry::Stoichiometry::Grammar --|> Chemistry::Stoichiometry::Grammar::ChemicalEquation
# Chemistry::Stoichiometry::Grammar --|> NQPMatchRole
#
#
# class Chemistry::Stoichiometry::Grammar::ChemicalEquation <<role>> {
# }
#
#
# class Chemistry::Stoichiometry::Grammar::ChemicalElement <<role>> {
# }
#
#
# class Chemistry::Stoichiometry::Actions::EquationBalance {
# }
# Chemistry::Stoichiometry::Actions::EquationBalance --|> Chemistry::Stoichiometry::Actions::EquationMatrix
#
#
# class Chemistry::Stoichiometry::Actions::MolecularMass {
# }
#
#
# class Chemistry::Stoichiometry::Actions::EquationMatrix {
# }
#
#
# class Chemistry::Stoichiometry::Actions::WL::System {
# }
#
#
# @enduml
```
Get WL UML graph spec for the package [AAp1]:
```
say to-uml-spec('Chemistry::Stoichiometry', format => 'wluml'):!methods:!attributes
```
```
# UMLClassGraph[
# "Parents" -> Flatten[{"Chemistry::Stoichiometry::Grammar" \[DirectedEdge] "Grammar", "Chemistry::Stoichiometry::Grammar" \[DirectedEdge] "Match", "Chemistry::Stoichiometry::Grammar" \[DirectedEdge] "Capture", "Chemistry::Stoichiometry::Grammar" \[DirectedEdge] "Chemistry::Stoichiometry::Grammar::ChemicalElement", "Chemistry::Stoichiometry::Grammar" \[DirectedEdge] "Chemistry::Stoichiometry::Grammar::ChemicalEquation", "Chemistry::Stoichiometry::Grammar" \[DirectedEdge] "NQPMatchRole", "Chemistry::Stoichiometry::Actions::EquationBalance" \[DirectedEdge] "Chemistry::Stoichiometry::Actions::EquationMatrix"}],
# "RegularMethods" -> Flatten[{}],
# "Abstract" -> Flatten[{"Chemistry::Stoichiometry::Grammar::ChemicalElement", "Chemistry::Stoichiometry::Grammar::ChemicalEquation", "NQPMatchRole"}],
# "EntityColumn" -> False, VertexLabelStyle -> "Text", ImageSize -> Large, GraphLayout -> Automatic]
```
### Classes in a name space
Get the classes, roles, subs, and constants of a namespace:
```
.say for namespace-types('ML::TriesWithFrequencies', :how-pairs).sort(*.key)
```
```
# ML::TriesWithFrequencies::LeafProbabilitiesGatherer => Perl6::Metamodel::ClassHOW
# ML::TriesWithFrequencies::ParetoBasedRemover => Perl6::Metamodel::ClassHOW
# ML::TriesWithFrequencies::PathsGatherer => Perl6::Metamodel::ClassHOW
# ML::TriesWithFrequencies::RegexBasedRemover => Perl6::Metamodel::ClassHOW
# ML::TriesWithFrequencies::ThresholdBasedRemover => Perl6::Metamodel::ClassHOW
# ML::TriesWithFrequencies::Trie => Perl6::Metamodel::ClassHOW
# ML::TriesWithFrequencies::TrieTraverse => Perl6::Metamodel::ParametricRoleGroupHOW
# ML::TriesWithFrequencies::Trieish => Perl6::Metamodel::ParametricRoleGroupHOW
# TRIEROOT => Str
# TRIEVALUE => Str
```
---
## Potential problems
### Mermaid JS
The package can export class diagrams in the
[Mermaid-JS format](https://mermaid-js.github.io/mermaid/#/classDiagram).
Unfortunately, currently (November 2022) Mermaid-JS does not support colon characters in class names.
Hence, colons are replaced with underscores.
Also, currently (November 2022) class specs in Mermaid-JS cannot be empty. I.e. the Mermaid JS code
generated here ***will not*** produce a diagram:
```
to-uml-spec --/methods --/attributes "ML::Clustering" --format=mermaid
```
```
# classDiagram
# class ML_Clustering_KMeans {
# }
# ML_Clustering_KMeans --|> ML_Clustering_DistanceFunctions
#
#
# class k_means {
# <<routine>>
# }
# k_means --|> Routine
# k_means --|> Block
# k_means --|> Code
# k_means --|> Callable
#
#
# class ML_Clustering_DistanceFunctions {
# <<role>>
# }
#
#
# class find_clusters {
# <<routine>>
# }
# find_clusters --|> Routine
# find_clusters --|> Block
# find_clusters --|> Code
# find_clusters --|> Callable
```
(Because of the empty definition `ML_Clustering_KMeans { }`.)
This command should produce Mermaid JS code that will produce diagram:
```
to-uml-spec --/methods --/attributes "ML::Clustering" --format=mermaid
```
---
## References
[AA1] Anton Antonov, et al.,
["Find programmatically all classes, grammars, and roles in a Raku package"](https://stackoverflow.com/q/68622047/14163984),
(2021),
[StackOverflow](https://stackoverflow.com).
[AA2] Anton Antonov,
["Generating UML diagrams for Raku namespaces"](https://community.wolfram.com/groups/-/m/t/2549055),
(2022),
[community.wolfram.com](https://community.wolfram.com).
[AAp1] Anton Antonov,
["UML Diagram Generation Mathematica package"](https://github.com/antononcube/MathematicaForPrediction/blob/master/Misc/UMLDiagramGeneration.m),
(2016),
[MathematicaForPrediction at GitHub/antononcube](https://github.com/antononcube).
[ES1] Eugene Steinberg and Vojtech Krasa,
[PlantUML integration IntelliJ IDEA plugin](https://plugins.jetbrains.com/plugin/7017-plantuml-integration),
[JetBrains Plugins Marketplace](https://plugins.jetbrains.com).
[GV1] [graphviz.org](https://graphviz.org).
[PUML1] [plantuml.com](https://plantuml.com).
[PUML2] [PlantUML online demo server](http://www.plantuml.com/plantuml).
[UMLD1] [uml-diagrams.org](https://www.uml-diagrams.org).
[WK1] Wikipedia entry, ["Graphviz"](https://en.wikipedia.org/wiki/Graphviz).
[WK2] Wikipedia entry, ["PlantUML"](https://en.wikipedia.org/wiki/PlantUML).
[WK3] Wikipedia entry, ["Unified Modeling Language"](https://en.wikipedia.org/wiki/Unified_Modeling_Language).
|
## make.md
make
Combined from primary sources listed below.
# [In Match](#___top "go to top of document")[§](#(Match)_routine_make "direct link")
See primary documentation
[in context](/type/Match#routine_make)
for **routine make**.
```raku
method make(Match:D: Mu $payload)
sub make(Mu $payload)
```
Sets the `.ast` attribute, which will be retrieved using `.made`.
```raku
$/.make("your payload here");
```
That is, it stores an arbitrary payload into the `Match` object that can later be retrieved via [`.made`](/routine/made) method. Since the sub form operates, by default, on `$/`, that example is equivalent to:
```raku
make("your payload here");
```
This is typically used in a [grammar](/language/grammars)'s actions class methods, where a piece of data is stored by one method and then later retrieved by another. It's up to you what data you store. It could be a tree node, [result of a calculation](/language/grammars#Proto_regexes), a type object, or a list of values.
The sub form operates on the current Match `$/`, which can be a convenient shortcut:
```raku
method my-action ($/) {
make "foo: $/";
}
```
|
## dist_zef-melezhik-Sparrowdo.md
# Sparrowdo
Run Sparrow tasks remotely (and not only)
# Build status
# Install
```
zef install Sparrowdo
```
# Usage
```
sparrowdo --host=remote-host [options]
```
For example:
```
# ssh host, bootstrap first, use of local repository
sparrowdo --host=13.84.166.232 --repo=file:///home/melezhik/repo --verbose --bootstrap
# docker host, don't add sudo
sparrowdo --docker=SparrowBird --image=alpine:latest --no_sudo
# localhost, with sudo
sparrowdo --localhost
# read hosts from file
sparrowdo --host=hosts.raku
```
# DSL
Sparrow6 DSL provides high level functions to manage configurations.
Just create a file named `sparrowdo` in current working directory and add few functions:
```
$ cat sparrowfile
user 'zookeeper';
group 'birds';
directory '/var/data/avifauna/greetings/', %( owner => 'zookeeper' );
file-create '/var/data/avifauna/greetings/sparrow.txt', %(
owner => 'zookeeper',
group => 'birds',
mode => '0644',
content => 'I am little but I am smart'
);
service-start 'nginx';
package-install ('nano', 'ncdu', 'mc' );
```
The full list of function is available at [Sparrow6 DSL](https://github.com/melezhik/Sparrow6/blob/master/documentation/dsl.md)
documentation.
If DSL is not enough you can call any Sparrow6 plugin using `task-run` function:
```
task-run "show me your secrets", "azure-kv-show", %(
kv => "Stash" # key vault name
secret => ( "password", "login" ) # secret names
)
```
## DSL vs `task-run` function
DSL is high level adapter with addition of some "syntax sugar" to make a code concise and readable.
DSL functions are Raku functions, you take advantage of input parameters validation.
However DSL is limited. Not every Sparrow6 plugin has related DSL function.
Once we've found some Sparrow6 plugin common enough we add a proper DSL wrapper for it.
In case you need more DSL wrappers let us know!
# Sparrowdo workflow
```
==================== ====================
| | --- [ Bootstrap ] | | LocalHost
| MasterHost | --- [ Sparrowdo Scenario ] ---> | TargetHost | Docker
| | * | | Ssh
==================== | ====================
{Sparrow6 Module} | {Sparrow6 Client}
\ parameters
\-----------------> [ tasks ]
^ ^ ^
/ / /
------------ / / /
{ Repository } ------------------
------------ [ plugins ]
-------------------
/ | | \
/ | | \
/ | | \
/ | | \
[CPAN] [RubyGems] [PyPi] [raku.land]
```
## Master host
Master host is where Sparrow6 tasks "pushed" from totarget hosts.
Sparrowdo should be installed on master host:
```
$ zef install Sparrowdo
```
## Sparrowdo scenario
Sparrowdo scenario is a collection of Sparrow6 tasks executed on target host.
## Target hosts
Target hosts are configured by Sparrow6 which should be installed there as well:
```
$ zef install Sparrow6
```
## Bootstrap
Bootstrap is process of automation of Sparrow6 installation on target host:
```
$ sparrowdo --host=192.168.0.1 --bootstrap
```
Bootstrap runs under `sudo` and requires sudo privileges on target host.
## Sudo
Execution of Sparrow6 tasks on target host is made under `sudo` by default, to disable this use `no_sudo` flag:
```
$ sparrowdo --docker=brave_cat --no_sudo # We don't need sudo on docker
```
## Various types of target hosts
Once sparrowfile is created it could be run on target host.
Ssh host:
```
$ sparrowdo --host=192.168.0.1
```
Docker container:
```
$ sparrowdo --docker=old_dog
```
Localhost:
```
$ sparrowdo --localhost
```
## Repositories
Sparrowdo use Sparrow6 repository to download tasks that are executed on target hosts.
During scenario execution Sparrowdo pulls plugins from repository and runs it *with parameters*.
Plugin that gets run with parameters is a Sparrow6 task.
* Detailed explanation of Sparrow6 tasks is available at [Sparrow6 development](https://github.com/melezhik/Sparrow6/blob/master/documentation/development.md) documentation.
* Detailed explanation of Sparrow6 plugins [Sparrow6 plugins](https://github.com/melezhik/Sparrow6/blob/master/documentation/plugins.md) documentation
* Detailed explanation of Sparrow6 repositories is available at [Sparrow6 repositories](https://github.com/melezhik/Sparrow6/blob/master/documentation/repository.md) documentation.
By default local repository located at `~/repo` is used:
```
$ sparrowdo --host=192.168.0.1 # using repo ~/repo
```
Use `--repo` flag to set repository URI. For example:
```
$ sparrowdo --repo=file:///tmp/repo --localhost # use /tmp/repo repository for local mode
$ docker run --name --name=fox -d sh -v /tmp/repo:/var/data
$ sparrowdo --repo=/var/data --docker=fox --repo=file://var/data # mount /tmp/repo to /var/data within docker instance
$ sparrowdo --repo=http://sparrow.repo # use http repository
```
Ssh mode supports synchronizing local file repositories with master and target host using scp.
It extremely useful if for some reason you can't use http based repositories:
```
# scp local repository /tmp/repo to target host
# and use it within target host
$ sparrowdo --sync=/tmp/repo --host=192.168.0.1
```
Read [Sparrow6 documentation](https://github.com/melezhik/Sparrow6/blob/master/documentation/repository.md)
to know more about Sparrow6 repositories.
# Sparrowdo files anatomy
When Sparrowdo scenario executed there are might be *related* that get *copied* to a target host,
for convenience, so that one can reliably refer to those files inside Sparrowdo scenario.
Thus Sparrowdo *project* might consists of various files and folders:
```
.
├── conf
│ └── alternative.pl6
├── config.raku
├── data
│ └── list.dat
├── files
│ └── baz.txt
├── sparrowfile
└── templates
└── animals.tmpl
```
* `sparrowfile`
The minimal setup is just `sparrowfile` placed in the current working directory.
That file contains Sparrowdo scenario to be executed.
One may optionally define other data that make up the whole set up:
* `conf`
Directory to hold configuration files
* `config.raku`
Default configuration file, if placed in current working directory will define Sparrowdo configuration, see
also [scenarios configuration](#scenario-configuration) section, alternatively one may place configuration file to `conf` directory and
choose to run with that file:
```
$ sparrowdo --conf=conf/alternative.pl6
```
* `files`
Directory containing files, so one could write such a scenario:
```
file "/foo/bar/baz.txt", %( source => "files/baz.txt" )
```
* `templates`
The same as `files` directory, but for templates, technically `templates` and `files` as equivalent, but
named separately for logical reasons. Obviously one can populate templates using that directory:
```
template-create '/var/data/animals.txt', %(
source => ( slurp 'templates/animals.tmpl' ),
owner => 'zookeeper',
group => 'animals' ,
mode => '644',
variables => %(
name => 'red fox',
language => 'English'
),
);
```
* `data`
The same as `files` and `templates` folder but to keep "data" files, just another folder
to separate logically different pieces of data:
```
file "/data/list.txt", %( source => "data/list.dat" )
```
# Scenario configuration
If `config.raku` file exists at the current working directory it *will be
loaded* via Raku [EVALFILE](https://docs.raku.org/routine/EVALFILE) at the *beginning* of scenario.
For example:
```
$ cat config.raku
{
user => 'foo',
install-base => '/opt/foo/bar'
}
```
Later on in the scenario you may access config data via `config` function, that returns
configuration as Raku Hash object:
```
$ cat sparrowfile
my $user = config<user>;
my $install-base = config<install-base>;
```
To refer configuration files at arbitrary location use `--conf` parameter:
```
$ sparrowdo --conf=conf/alternative.conf
```
See also [Sparrowdo files anatomy](#sparrowdo-files-anatomy) section.
# Including other Sparrowdo scenarios
Because Sparrowdo scenarios are Raku code files, you're free to include other scenarios into
"main" one using via Raku [EVALFILE](https://docs.raku.org/routine/EVALFILE) mechanism:
```
$ cat sparrowfile
EVALFILE "another-sparrowfile";
```
Including another scenario does not include related files (`data`, `files`, `templates`) into main one,
so you can only reuse Sparrowdo scenario itself, but not it's *related* files.
# Bootstrap and manual install
To ensure that target hosts has all required Sparrow6 dependencies one may choose bootstrap mechanism that
installs those dependencies on target host. This operation is carried out under `sudo`.
Bootstrap is disabled by default and should be enabled by `--bootstrap` option:
```
$ sparrowdo --host=192.168.0.1 --bootstrap
```
Be aware that all dependencies will be installed *system wide* rather then user account, because `sudo` is used.
if you don't want bootstrap target host, you can always choose to install Sparrow6 zef module
on target host, which is enough to start using Sparrowdo to manage target host:
```
$ zef install Sparrow6
```
# Run Sparrowdo on docker
Sparrowdo supports docker as target host, just refer to running docker container by name to
run Sparrowdo scenario on it:
```
$ sparrowdo --docker=running-horse
```
If you need to pull an image first and then run docker container
for this image, choose `--image` option:
```
$ sparrowdo --docker=running-horse --image=alpine:latest --bootstrap --no_sudo
```
# Run Sparrowdo on ssh hosts
This is probably one the most common use case for Sparrowdo - configuring servers by ssh:
```
$ sparrowdo --host=192.168.0.1
```
# Run Sparrowdo in local mode
In case you need to run sparrowdo on localhost use `--localhost` flag:
```
$ sparrowdo --localhost
```
# Sparrowdo cli
`sparrowdo` is Sparrowdo cli to run Sparrowdo scenarios, it accepts following arguments:
* `--host`
One of two things:
Ssh host to run Sparrowdo scenario on. Default value is `127.0.0.1`. For example:
```
--host=192.168.0.1
```
Path to raku file with hosts configuration. For example:
```
--host=hosts.raku
```
This will effectively runs Sparrowdo in asynchronous mode through Sparky backend.
See [Sparky integration](https://github.com/melezhik/sparrowdo/blob/master/doc/sparky-integration.md) doc.
* `--workers`
Number of asynchronous workers when run in asynchronous mode through Sparky backend
See [Sparky integration](https://github.com/melezhik/sparrowdo/blob/master/doc/sparky-integration.md) doc.
* `--watch`
Runs watcher job
See [Sparky integration](https://github.com/melezhik/sparrowdo/blob/master/doc/sparky-integration.md#watcher-jobs) doc.
* `--docker`
Name of docker container to run sparrowdo scenario on, to run docker container first
after pulling an image use `--image` option
* `--localhost`
If set, runs Sparrowdo in localhost, in that case Sparrow6 tasks get run directly without launching ssh.
* `--with_sparky`
If set, run in asynchronous mode through Sparky backend.
See [Sparky integration](https://github.com/melezhik/sparrowdo/blob/master/doc/sparky-integration.md#watcher-jobs) doc.
* `--desc`
Set a descriptive name to a build, only works when run in asynchronous mode through Sparky backend
* `--ssh_user`
If set defines ssh user when run Sparrowdo scenario over ssh, none required.
* `--ssh_port`
If set defines ssh port to use when run Sparrowdo scenario over ssh. Default value is 22.
If set, run Sparrowdo scenario on localhost, don't confuse with `--host=127.0.0.1` which
runs scenario on the machine but using ssh.
* `--repo`
Defines Sparrow6 repository `URI`, for example:
```
--repo=https://192.168.0.1 # Remote http repository
--repo=file:///var/data/repo # Local file system repository
```
If `--repo` is not set, Sparrowdo uses default local repository located at `~/repo` path.
Sparrowdo uses repository to pull plugins from, see also [Sparrowdo workflow](#sparrowdo-workflow) section.
See also [Sparrow6 Repositories](https://github.com/melezhik/Sparrow6/blob/master/documentation/repository.md)
documentation.
* `--sync`
If set synchronize local file system repository with target hosts using `scp`, it's useful if for some reasons
remote http repositories are not available or disable, so one can *automatically copy* repository from master host
to target. `--sync` parameter value should file path pointing repository directory at master host:
```
--sync=/var/data/repository
```
* `--no_index_update`
If set, don't request Sparrow6 repository update. Useful when in limited internet and using http based remote repositories.
* `--dry_run`
Runs in dry run mode. Only applies when run in asynchronous mode through a Sparky backend.
See [Sparky integration](https://github.com/melezhik/sparrowdo/blob/master/doc/sparky-integration.md) doc.
* `--tags`
Set host(s) tags, see [Sparky integration](https://github.com/melezhik/sparrowdo/blob/master/doc/sparky-integration.md) doc.
* `--color`
Enable color output. Disabled by default.
* `--verbose`
If set print additional information during Sparrowdo scenario execution.
* `--debug`
If set, runs Sparrow6 tasks in `debug` mode, giving even more information, during scenario execution.
* `--prefix`
If set, define path to be appending to local cache directory on target host, used predominantly
when running concurrent Sparrowdo scenario on one target host, for example in Sparky CI server.
None required, no default value.
# Advanced topics
[Run Sparrowdo scenarios in asynchronous mode, using Sparky backend](https://github.com/melezhik/sparrowdo/blob/master/doc/sparky-integration.md)
# Author
Alexey Melezhik
# See also
* [Sparrow6](https://github.com/melezhik/Sparrow6)
# Thanks
To God as the One Who inspires me to do my job!
|
## dist_zef-tony-o-Uxmal.md
# Uxmal
Analyses the an array of META6.json-ish hashes to determine the required build order and also provides a control mechanism for building as efficiently as possible.
## `depends-tree(@meta)`
Really only needs an array of `{ :name, :depends([]) }` of all of the dependencies required
## `depends-channel(%tree, $concurrency = 3)`
Returns a `Channel` you can use for flow control for whatever you're doing.
Example:
```
my %tree = depends-tree(@list-of-metas);
my $flow = depends-channel(%tree);
loop {
if $flow.poll -> $key {
# do something with %tree{$k}
%tree{$k}<promise>.keep; # this is important so the controller
# knows it can send the next item to be
# built
}
if $flow.closed { last }
sleep .5;
};
```
Check out `t/build-order.t:32` for a more complex example.
## `generate-dot(%tree)`
Returns a very simply graphviz dot format string that you can use to write to a file and generate a chart.
## `attempt-full-dot-gen(%tree, :$force = False)`
Will `die` if `$force ~~ False` or if `which dot` does not return the path to graphviz's `dot`.
This method attempts to generate the dot file, runs `dot -T png -o <tmp-file.png> <tmp-file.dot>` and returns the string path to the png file.
|
## dist_github-Mouq-TOML.md
## TOML.pm6
A WIP ~250 line TOML parser and serializer written in Perl 6.
### Synopsis
```
use TOML;
say from-toml q:/.../;
[TOML]
format = "simple"
[TOML.types]
bool = true
strings = "true"
dates = 1996-08-28T21:11:00Z
arrays = [ "yep", "got 'em too" ]
...
```
### Testing
Tests are currently done via [toml-test](https://github.com/BurntSushi/toml-test).
To test TOML.pm6, Go must be installed. Then, install toml-test via:
```
cd
export GOPATH=$HOME/go
go get github.com/BurntSushi/toml-test
```
And then test TOML.pm6 with:
```
cd -1
$HOME/go/bin/toml-test bin/toml2json
```
### TODO
* TOML encoding
* Perl 6 test harness
* Better errors
|
## dist_cpan-JFORGET-Date-Calendar-Bahai.md
# NAME
Date::Calendar::Bahai - Conversions from / to the Baháʼí calendar
# SYNOPSIS
```
use Date::Calendar::Bahai;
my Date $dt-greg;
my Date::Calendar::Bahai $dt-bahai;
$dt-greg .= new(2021, 5, 17);
$dt-bahai .= new-from-date($dt-greg);
say $dt-bahai;
# --> 0178-04-01
say $dt-bahai.strftime("%A %d %B %Y");
# --> Kamál 1 ‘Aẓamat 178
```
Converting a Bahai date (e.g. 19 Jamál 178) into Gregorian
```
use Date::Calendar::Bahai;
my Date::Calendar::Bahai $dt-bahai;
my Date $dt-greg;
$dt-bahai .= new(year => 178, month => 3, day => 19);
$dt-greg = $dt-bahai.to-date;
say $dt-greg;
# --> 2021-05-16
```
# DESCRIPTION
Date::Calendar::Bahai is a class representing dates in the Baháʼí
calendar. It allows you to convert a Baháʼí date into Gregorian or
into other implemented calendars, and it allows you to convert dates
from Gregorian or from other calendars into Baháʼí.
The Date::Calendar::Bahai class gives the early version of the Baháʼí
calendar, which is synchronised with the Gregorian calendar. The new
version, after the 2015 reform, is partially implemented in
Date::Calendar::Bahai::Astronomical, included in this distribution.
# INSTALLATION
```
zef install Date::Calendar::Bahai
```
or
```
git clone https://github.com/jforget/raku-Date-Calendar-Bahai.git
cd raku-Date-Calendar-Bahai
zef install .
```
# AUTHOR
Jean Forget [JFORGET@cpan.org](mailto:JFORGET@cpan.org)
# COPYRIGHT AND LICENSE
Copyright 2021 Jean Forget
This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.
|
## dist_github-sylvarant-Avro.md
# perl6 Avro support
[](https://travis-ci.org/sylvarant/Avro) [](https://opensource.org/licenses/Artistic-2.0)
Provides a native perl6 implementation of the [Avro specification](https://avro.apache.org/docs/current/spec.html).
## TODO
This is a work in progress.
Still to implement:
* : Reader schemas and resolution
* : JSON output (OPTIONAL)
## Example
The official [python example](https://avro.apache.org/docs/current/gettingstartedpython.html) can be rewritten in perl6 as follows.
```
use Avro;
my $path = "testfile";
my $avro_ex = Q<<{ "namespace": "example.avro",
"type": "record",
"name": "User",
"fields": [
{"name": "name", "type": "string"},
{"name": "favorite_number", "type": ["int", "null"]},
{"name": "favorite_color", "type": ["string", "null"]}]}>>;
my $schema = parse-schema($avro_ex);
my $writer = Avro::DataFileWriter.new(:handle($path.IO.open(:w)),:schema($schema));
$writer.append({"name" => "Alyssa","favorite_number" => 256,});
$writer.append({"name" => "Ben", "favorite_number" => 7, "favorite_color" => "red"});
$writer.close();
my $reader = Avro::DataFileReader.new(:handle($path.IO.open(:r)));
repeat {
say $reader.read();
} until $reader.eof;
$reader.close()
```
## License
[Artistic License 2.0](http://www.perlfoundation.org/artistic_license_2_0)
|
## dist_zef-guifa-UserTimezone.md
# User::Timezone
**Important notice:** This module was previously known as `Intl::UserTimezone`. Its name was changed to align with similar modules. It will still be usable as `Intl::UserTimezone` until the end of 2024 to give ample time for the change to happen.
A simple Raku module for determining the user's timezone as an Olson (IANA or tz) identifier, particularly useful when formatting dates.
To use:
```
use User::Timezone;
say user-timezone; # 'America/New_York'
# 'Africa/Malabo'
# 'Asia/Tokyo'
# 'Etc/GMT'
```
The returned string does *not* apply a metazone.
If you wish to show a user-facing string like, e.g., "Central European Time", you should use the appropriate functions from `Intl::DateTime` (NYI, might go into `DateTime::*`, haven't decided yet ^\_^).
## Options
The default fallback (in case detection fails) is **Etc/GMT**.
If for some reason you wish to use a different one, pass it as a positional argument in the use statement.
Note that this has *global* effects:
```
use User::Timezone 'Asia/Qyzylorda'
```
Similarly, you can *force* a certain timezone which is useful when testing out aspects of your program that may be sensitive to timezones.
To do that, include the override option.
```
use User::Timezone :override;
```
This will import two additional subroutines into your scope:
```
override-user-timezone(Str $olson-id)
clear-user-timezone-override
```
These do exactly what their names imply.
Again, be aware that their effects are global.
## Compatibility / Implementation Notes
For Mac OS and most \*nix systems, the region is accurately grabbed from `/etc/localtime` if it exists.
Currently timezones indicated by the `$TZ` environmental variable are ignored, but will eventually be supported.
For Windows, the ID should be acceptable and better than a GMT offset, but may occasionally be suboptimal.
This is because Windows uses its own custom timezone identifiers that do not have a one-to-one relationship with Olsen IDs.
The Windows timezone ID is combined with the Windows GeoID to provide a best-guess that should generally be accurate.
For example, if your Windows timezone is "Central Standard Time", and your GeoID is 244 (United States), then it will be reported as **America/Chicago** (others are possible, but there is not enough information to differentiate with **America/Indiana/Knox**, so the broadest is used).
But if your GeoID is 39 (Canada), then it will be reported as **America/Winnipeg**.
## What if it doesn't work
If there is a problem determining the timezone, the default will be `Etc/GMT`, being the most generic, although that's not really an acceptable alternative.
If it's clear that `User::Timezone` cannot determine things for your operating system, or is in some other way not returning the correct results, please file an issue on Github and let's figure out how to make it work on your system.
# Version history
* **v0.3.1**
* Updated Windows zones data files
* **v0.3.0**
* Changed name to `User::Timezone` and added a fallback message for older uses
* Adjusted Mac OS detection for improved accuracy
* **v0.2**
* Added option for a custom fallback (in case detection fails)
* Added ability for overriding the timezone (mainly for testing purposes)
* **v0.1.1**
* Removed test code that prevented correct Windows detection.
* Chomped output to facilitate use in other modules.
* **v0.1**
* Initial release with support for macOS, most \*nix machines and beta support Windows
# License
Except as indicated, this module and all its files is provided under the Artistic License 2.0.
## Except as indicated
The file `windowsZones.xml` is Copyright 2020 The Unicode Consortium, and distributed without modification in accordance with its [license/terms of use](https://www.unicode.org/copyright.html).
|
## dist_cpan-MATIASL-Matrix-Client.md
# Matrix::Client
A [Raku](https://raku.org) library for [Matrix](https://matrix.org).
## Installation
```
zef install Matrix::Client
```
## Usage
```
use Matrix::Client;
my $client = Matrix::Client.new(
:home-server<https://matrix.org>,
:device-id<matrix-client>
);
$client.login(:username<myuser>, :password<s3cr3t>);
# Check my user
say $client.whoami; # @myuser:matrix.org
# Send a message to a random room that I'm in
my $room = $client.joined-rooms.pick;
say "Sending a message to {$room.name}";
$room.send("Hello from Raku!");
```
## Description
Matrix is an open network for secure, decentralized communication.
This module provides an interface to interact with a Matrix homeserver through
the *Client-Server API*. It's currenlty on active development but it's mostly
stable for day to day use.
Here's a not complete list of things that can be done:
* Login/logout
* Registration
* Synchronization of events/messages
* Send events
* Send messages
* Upload files to a home-server
There are many missing endpoints (you can check a complete checklist
[here](https://github.com/matiaslina/perl6-matrix-client/blob/master/endpoints.md)).
If you want to contribute with some endpoint check the
<CONTRIBUTING.md> file.
## Documentation
There's a couple of pages of documentation on the `docs/` directory. This
includes API documentation, basic usage, examples, etc.
## Author
Matías Linares [matias@deprecated.org](mailto:matias@deprecated.org) | Matrix ID: `@matias:chat.deprecated.org`
|
## dist_zef-antononcube-DSL-Entity-MachineLearning.md
# DSL::Entity::MachineLearning (Raku package)
Raku grammar classes for Machine Learning (ML) entities (names.)
The package does entity name recognition using regexes over a set of
hashes (dictionaries) that map entity name phrases into entity Identifiers (IDs).
The hashes are obtained from [the resource files](./resources).
In short, we say that the package has grammar-resource-based architecture.
The same architecture is used in the Domain Specific Language (DSL) entity packages [AAr3-AAr6].
**Remark:** It is assumed that the associations between entity name phrases and entity IDs
placed in the resource files are going to be changed in the future, because of classifier
systems updates, or usage feedback. This is one of the main reasons to use grammar-resource-based
architecture: subsequent package versions would have better, fuller associations.
---
## Installation
```
zef install https://github.com/antononcube/Raku-DSL-Entity-MachineLearning.git
```
---
## Usage examples
```
use DSL::Entity::MachineLearning;
use DSL::Entity::MachineLearning::ResourceAccess;
my $pCOMMAND = DSL::Entity::MachineLearning::Grammar;
$pCOMMAND.set-resources(DSL::Entity::MachineLearning::resource-access-object());
say $pCOMMAND.parse('DecisionTree', rule => 'machine-learning-entity-command');
say $pCOMMAND.parse('gradient boosted trees', rule => 'machine-learning-entity-command');
say $pCOMMAND.parse('roc curve', rule => 'machine-learning-entity-command');
```
```
# ｢DecisionTree｣
# classifier-entity-command => ｢DecisionTree｣
# entity-classifier-name => ｢DecisionTree｣
# 0 => ｢DecisionTree｣
# word-value => ｢DecisionTree｣
# ｢gradient boosted trees｣
# classifier-entity-command => ｢gradient boosted trees｣
# entity-classifier-name => ｢gradient boosted trees｣
# 0 => ｢gradient boosted trees｣
# word-value => ｢gradient｣
# word-value => ｢boosted｣
# word-value => ｢trees｣
# ｢roc curve｣
# classifier-measurement-entity-command => ｢roc curve｣
# entity-classifier-measurement-name => ｢roc curve｣
# 0 => ｢roc curve｣
# word-value => ｢roc｣
# word-value => ｢curve｣
```
---
## Command line interface
The package provide as Command Line Interface (CLI) to its functionalities:
```
> ToMachineLearningEntityCode --help
# Usage:
# ToMachineLearningEntityCode <command> [--target=<Str>] [--user=<Str>] -- Conversion of (natural) DSL machine learning entity name into code.
# ToMachineLearningEntityCode <target> <command> [--user=<Str>] -- Both target and command as arguments.
#
# <command> natural language command (DSL commands)
# --target=<Str> target language/system/package (defaults to 'WL-System') [default: 'WL-System']
# --user=<Str> user identifier (defaults to '') [default: '']
# <target> Programming language.
```
**Remark:** (Currently) the CLI script always returns results in JSON format.
---
## Resource files
The resource file:
1. ["ClassifierNameToEntityID\_EN.csv"](./resources/ClassifierNameToEntityID_EN.csv),
was derived from the Mathematica function page for
[`Classify`](https://reference.wolfram.com/language/ref/Classify.html), [WRI1].
2. ["ClassifierMeasurementNameToEntityID\_EN.csv"](./resources/ClassifierMeasurementNameToEntityID_EN.csv)
was derived using Mathematica's built-in function
[`ClassifierMeasurements`](https://reference.wolfram.com/language/ref/ClassifierMeasurements.html), [WRI3].
Some additional associations were put in following [WK1].
3. ["ClassifierPropertyNameToEntityID\_EN.csv"](./resources/ClassifierPropertyNameToEntityID_EN.csv),
was derived using Mathematica's built-in function
[`Information`](https://reference.wolfram.com/language/ref/Information.html), [WRI4].
4. ["ROCFunctionNameToEntityID\_EN.csv"](./resources/ROCFunctionNameToEntityID_EN.csv)
uses the names and mappings in [WK1]. (See also the related package [AAr7].)
The initial versions Bulgarian versions of the resource files with name suffix "\_BG.csv" were
derived by automatic translations of the corresponding English content.
Afterwards the Bulgarian mappings were reviewed and manually modified.
---
## References
### Articles
[WK1] Wikipedia entry, ["Receiver operating characteristic"](https://en.wikipedia.org/wiki/Receiver_operating_characteristic).
### Wolfram Language (WL) articles and functions
[WRI1] Wolfram Research (2014),
[Classify](https://reference.wolfram.com/language/ref/Classify.html),
Wolfram Language function, <https://reference.wolfram.com/language/ref/Classify.html> (updated 2021).
[WRI2] Wolfram Research, Inc.,
[Machine Learning Methods](https://reference.wolfram.com/language/guide/MachineLearningMethods.html).
[WRI3] Wolfram Research (2014),
[ClassifierMeasurements](https://reference.wolfram.com/language/ref/ClassifierMeasurements.html),
Wolfram Language function, <https://reference.wolfram.com/language/ref/ClassifierMeasurements.html> (updated 2021).
[WRI4] Wolfram Research (1988),
[Information](https://reference.wolfram.com/language/ref/Information.html),
Wolfram Language function, <https://reference.wolfram.com/language/ref/Information.html> (updated 2021).
### Repositories
[AAr1] Anton Antonov,
[DSL::English::ClassificationWorkflows Raku package](https://github.com/antononcube/Raku-DSL-English-ClassificationWorkflows),
(2020-2022),
[GitHub/antononcube](https://github.com/antononcube).
[AAr2] Anton Antonov,
[DSL::Shared Raku package](https://github.com/antononcube/Raku-DSL-Shared),
(2020),
[GitHub/antononcube](https://github.com/antononcube).
[AAr3] Anton Antonov,
[DSL::Entity::Geographics Raku package](https://github.com/antononcube/Raku-DSL-Entity-Geographics),
(2021),
[GitHub/antononcube](https://github.com/antononcube).
[AAr4] Anton Antonov,
[DSL::Entity::Jobs Raku package](https://github.com/antononcube/Raku-DSL-Entity-Jobs),
(2021),
[GitHub/antononcube](https://github.com/antononcube).
[AAr5] Anton Antonov,
[DSL::Entity::Foods Raku package](https://github.com/antononcube/Raku-DSL-Entity-Foods),
(2021),
[GitHub/antononcube](https://github.com/antononcube).
[AAr6] Anton Antonov,
[DSL::Entity::Metadata Raku package](https://github.com/antononcube/Raku-DSL-Entity-Metadata),
(2021),
[GitHub/antononcube](https://github.com/antononcube).
[AAr7] Anton Antonov,
[ML::ROCFunctions Raku package](https://github.com/antononcube/Raku-ML-ROCFunctions),
(2022),
[GitHub/antononcube](https://github.com/antononcube).
|
## dist_zef-dwarring-PDF.md
[[Raku PDF Project]](https://pdf-raku.github.io)
/ [PDF](https://pdf-raku.github.io/PDF-raku)
[](https://github.com/pdf-raku/PDF-raku/actions)
# PDF-raku
## Overview
This is a low-level Raku module for accessing and manipulating data from PDF documents.
It presents a seamless view of the data in PDF or FDF documents; behind the scenes handling indexing, compression, encryption, fetching of indirect objects and unpacking of object streams. It is capable of reading, editing and creation or incremental update of PDF files.
This module understands physical data structures rather than the logical document structure. It is primarily intended as base for higher level modules; or to explore or patch data in PDF or FDF files.
It is possible to construct basic documents and perform simple edits by direct manipulation of PDF data. This requires some knowledge of how PDF documents are structured. Please see 'The Basics' and 'Recommended Reading' sections below.
Classes/roles in this module include:
* `PDF` - PDF document root (trailer)
* `PDF::IO::Reader` - for indexed random access to PDF files
* `PDF::IO::Filter` - a collection of standard PDF decoding and encoding tools for PDF data streams
* `PDF::IO::IndObj` - base class for indirect objects
* `PDF::IO::Serializer` - data marshalling utilities for the preparation of full or incremental updates
* `PDF::IO::Crypt` - decryption / encryption
* `PDF::IO::Writer` - for the creation or update of PDF files
* `PDF::COS` - Raku Bindings to PDF objects [Carousel Object System, see [COS](http://jimpravetz.com/blog/2012/12/in-defense-of-cos/)]
## Example Usage
To create a one page PDF that displays 'Hello, World!'.
```
#!/usr/bin/env raku
# creates examples/helloworld.pdf
use PDF;
use PDF::COS::Name;
use PDF::COS::Dict;
use PDF::COS::Stream;
use PDF::COS::Type::Info;
sub prefix:</>($s) { PDF::COS::Name.COERCE($s) };
# construct a simple PDF document from scratch
my PDF $pdf .= new;
my PDF::COS::Dict $catalog = $pdf.Root = { :Type(/'Catalog') };
my @MediaBox = 0, 0, 250, 100;
# define font /F1 as core-font Helvetica
my %Resources = :Font{
:F1{
:Type(/'Font'),
:Subtype(/'Type1'),
:BaseFont(/'Helvetica'),
:Encoding(/'MacRomanEncoding'),
},
};
my PDF::COS::Dict $page-index = $catalog<Pages> = { :Type(/'Pages'), :@MediaBox, :%Resources, :Kids[], :Count(0) };
# add some standard metadata
my PDF::COS::Type::Info $info = $pdf.Info //= {};
$info.CreationDate = DateTime.now;
$info.Producer = "Raku PDF";
# define some basic content
my PDF::COS::Stream() $Contents = { :decoded("BT /F1 24 Tf 15 25 Td (Hello, world!) Tj ET" ) };
# create a new page. add it to the page tree
$page-index<Kids>.push: { :Type(/'Page'), :Parent($page-index), :$Contents };
$page-index<Count>++;
# save the PDF to a file
$pdf.save-as: 'examples/helloworld.pdf';
```
Then to update the PDF, adding another page:
```
#!/usr/bin/env raku
use PDF;
use PDF::COS::Stream;
use PDF::COS::Type::Info;
my PDF $pdf .= open: 'examples/helloworld.pdf';
# locate the document root and page tree
my $catalog = $pdf<Root>;
my $Parent = $catalog<Pages>;
# create additional content, use existing font /F1
my PDF::COS::Stream() $Contents = { :decoded("BT /F1 16 Tf 15 25 Td (Goodbye for now!) Tj ET" ) };
# create a new page. add it to the page-tree
$Parent<Kids>.push: { :Type( :name<Page> ), :$Parent, :$Contents };
$Parent<Count>++;
# update or create document metadata. set modification date
my PDF::COS::Type::Info $info = $pdf.Info //= {};
$info.ModDate = DateTime.now;
# incrementally update the existing PDF
$pdf.update;
```
## Description
A PDF file consists of data structures, including dictionaries (hashes) arrays, numbers and strings, plus streams for holding graphical data such as images, fonts and general content.
PDF files are also indexed for random access and may also have internal compression and/or encryption.
They have a reasonably well specified structure. The document starts from the `Root` entry in the trailer dictionary, which is the main entry point into a PDF.
This module is based on the [PDF 32000-1:2008 1.7](https://opensource.adobe.com/dc-acrobat-sdk-docs/standards/pdfstandards/pdf/PDF32000_2008.pdf) specification. It implements syntax, basic data-types, serialization and encryption rules as described in the first four chapters of the specification. Read and write access to data structures is via direct manipulation of tied arrays and hashes.
## The Basics
The `examples/helloworld.pdf` file that we created above contains:
```
%PDF-1.4
%...(control characters)
1 0 obj
<< /CreationDate (D:20151225000000Z00'00') /Producer (Raku PDF) >>
endobj
2 0 obj
<< /Type /Catalog /Pages 3 0 R >>
endobj
3 0 obj
<<
/Type /Pages
/Count 1
/Kids [ 4 0 R ]
/MediaBox [ 0 0 250 100 ]
/Resources << /Font << /F1 6 0 R >> >>
>>
endobj
4 0 obj
<< /Type /Page /Contents 5 0 R /Parent 3 0 R >>
endobj
5 0 obj
<< /Length 44 >> stream
BT /F1 24 Tf 15 25 Td (Hello, world!) Tj ET
endstream
endobj
6 0 obj
<<
/Type /Font
/Subtype /Type1
/BaseFont /Helvetica
/Encoding /MacRomanEncoding
>>
endobj
xref
0 7
0000000000 65535 f
0000000015 00000 n
0000000098 00000 n
0000000148 00000 n
0000000283 00000 n
0000000347 00000 n
0000000442 00000 n
trailer
<<
/ID [ <2086649e71c387e1fd583111ee195fe5> <2086649e71c387e1fd583111ee195fe5> ]
/Info 1 0 R
/Root 2 0 R
/Size 7
>>
startxref
549
%%EOF```
The PDF is composed of a series indirect objects, for example, the first object is:
```
1 0 obj
<< /CreationDate (D:20151225000000Z00'00') /Producer (Raku PDF)>>
endobj
```
It's an indirect object with object number `1` and generation number `0`, with a `<<` ... `>>` delimited dictionary containing the author and the date that the document was created. This PDF dictionary is roughly equivalent to the Raku hash:
``` { :CreationDate("D:20151225000000Z00'00'"), :Producer("Raku PDF"), } ```
The bottom of the PDF contains:
```
trailer
<<
/ID [ <2086649e71c387e1fd583111ee195fe5> <2086649e71c387e1fd583111ee195fe5> ]
/Info 1 0 R
/Root 2 0 R
/Size 7
startxref
549
%%EOF
```
The `<<` ... `>>` delimited section is the trailer dictionary and the main entry point into the document. The entry `/Info 1 0 R` is an indirect reference to the first object (object number 1, generation 0) described above. The entry `/Root 2 0 R` points the root of the actual PDF document,
commonly known as the Document Catalog.
Immediately above the trailer is the cross reference table:
```
xref
0 7
0000000000 65535 f
0000000015 00000 n
0000000098 00000 n
0000000148 00000 n
0000000283 00000 n
0000000347 00000 n
0000000442 00000 n
```
This indexes the indirect objects in the PDF by byte offset (and generation number) for random access.
We can quickly put PDF to work using the Raku REPL, to better explore the document:
snoopy: ~/git/PDF-raku $ raku -M PDF
> my $pdf = PDF.open: "examples/helloworld.pdf"
ID => [CÜ{ÃHADCN:C CÜ{ÃHADCN:C], Info => ind-ref => [1 0], Root => ind-ref => [2 0]
> $pdf.keys
(Root Info ID)
This is the root of the PDF, loaded from the trailer dictionary
> $pdf<Info>
{CreationDate => D:20151225000000Z00'00', ModDate => D:20151225000000Z00'00', Producer => Raku PDF}
That's the document information entry, commonly used to store basic meta-data about the document.
(PDF::IO has conveniently fetched indirect object 1 from the PDF, when we dereferenced this entry).
> $pdf<Root>
{Pages => ind-ref => [3 0], Type => Catalog}
The trailer `Root` entry references the document catalog, which contains the actual PDF content. Exploring further; the catalog potentially contains a number of pages, each with content.
> $pdf<Root><Pages>
{Count => 1, Kids => [ind-ref => [4 0]], MediaBox => [0 0 420 595], Resources => Font => F1 => ind-ref => [6 0], Type => Pages}
> $pdf<Root><Pages><Kids>[0]
{Contents => ind-ref => [5 0], Parent => ind-ref => [3 0], Type => Page}
> $pdf<Root><Pages><Kids>[0]<Contents>
{Length => 44}
"BT /F1 24 Tf 15 25 Td (Hello, world!) Tj ET"
The page `/Contents` entry is a PDF stream which contains graphical instructions. In the above example, to output the text `Hello, world!` at coordinates 100, 250.
## Reading and Writing of PDF files:
`PDF` is a base class for opening or creating PDF documents.
- `my $pdf = PDF.open("mydoc.pdf" :repair)`
Opens an input `PDF` (or `FDF`) document.
- `:!repair` causes the read to load only the trailer dictionary and cross reference tables from the tail of the PDF (Cross Reference Table or a PDF 1.5+ Stream). Remaining objects will be lazily loaded on demand.
- `:repair` causes the reader to perform a full scan, ignoring and recalculating the cross reference stream/index and stream lengths. This can be handy if the PDF document has been hand-edited.
- `$pdf.update`
This performs an incremental update to the input pdf, which must be indexed `PDF` (not applicable to PDFs opened with `:repair`, FDF or JSON files). A new section is appended to the PDF that contains only updated and newly created objects. This method can be used as a fast and efficient way to make small updates to a large existing PDF document.
- `:diffs(IO::Handle $fh)` - saves just the updates to an alternate location. This can be later appended to the base PDF to reproduce the updated PDF.
- `$pdf.save-as("mydoc-2.pdf", :compress, :stream, :preserve, :rebuild)`
Saves a new document, including any updates. Options:
- `:compress` - compress objects for minimal size
- `:!compress` - uncompress objects for human readability
- `:stream` - write the PDF progressively
- `:preserve` - copy the input PDF, then incrementally update. This is generally faster and ensures that any digital signatures are not invalidated,
- `:rebuild` - discard any unreferenced objects. renumber remaining objects. It may be a good idea to rebuild a PDF Document, that's been incrementally updated a number of times.
Note that the `:compress` and `:rebuild` options are a trade-off. The document may take longer to save, however file-sizes and the time needed to reopen the document may improve.
- `$pdf.save-as("mydoc.json", :compress, :rebuild); my $pdf2 = $pdf.open: "mydoc.json"`
Documents can also be saved and opened from an intermediate `JSON` representation. This can be handy for debugging, analysis and/or ad-hoc patching of PDF files.
### Reading PDF Files
The `.open` method loads a PDF index (cross reference table and/or stream). The document can then be access randomly via the
`.ind.obj(...)` method.
The document can be traversed by dereferencing Array and Hash objects. The reader will load indirect objects via the index, as needed.
```
use PDF::IO::Reader;
use PDF::COS::Name;
my PDF::IO::Reader $reader .= new;
$reader.open: 'examples/helloworld.pdf';
# Objects can be directly fetched by object-number and generation-number:
my $page1 = $reader.ind-obj(4, 0).object;
# Hashes and arrays are tied. This is usually more convenient for navigating
my $pdf = $reader.trailer;
$page1 = $pdf[0];
# Tied objects can also be updated directly.
$reader.trailer = PDF::COS::Name.COERCE: 't/helloworld.t';
```
### Utility Scripts
- `pdf-rewriter.raku [--repair] [--rebuild] [--stream] [--[/]compress] [--password=Xxx] [--decrypt] [--class=Module] [--render] <pdf-or-json-file-in> [<pdf-or-json-file-out>]`
This script is a thin wrapper for the `PDF` `.open` and `.save-as` methods. It can typically be used to:
- uncompress or render a PDF for human readability
- repair a PDF who's cross-reference index or stream lengths have become invalid
- convert between PDF and JSON
### Decode Filters
Filters are used to compress or decompress stream data in objects of type `PDF::COS::Stream`. These are implemented as follows:
*Filter Name* | *Short Name* | Filter Class
--- | --- | ---
ASCIIHexDecode | AHx | PDF::IO::Filter::ASCIIHex
ASCII85Decode | A85 | PDF::IO::Filter::ASCII85
CCITTFaxDecode | CCF | _NYI_
Crypt | | _NYI_
DCTDecode | DCT | _NYI_
FlateDecode | Fl | PDF::IO::Filter::Flate
LZWDecode | LZW | PDF::IO::Filter::LZW (`decode` only)
JBIG2Decode | | _NYI_
JPXDecode | | _NYI_
RunLengthDecode | RL | PDF::IO::Filter::RunLength
Input to all filters is byte strings, with characters in the range \x0 ... \0xFF. latin-1 encoding is recommended to enforce this.
Each filter has `encode` and `decode` methods, which accept and return latin-1 encoded strings, or binary blobs.
```
my Blob $encoded = PDF::IO::Filter.encode( :dict{ :Filter },
"This is waaay toooooo loooong!");
say $encoded.bytes;
```
### Encryption
PDF::IO::Crypt supports RC4 and AES encryption (revisions /R 2 - 4 and versions /V 1 - 4 of PDF Encryption).
To open an encrypted PDF document, specify either the user or owner password: `PDF.open( "enc.pdf", :password<ssh!>)`
A document can be encrypted using the `encrypt` method: `$pdf.encrypt( :owner-pass<ssh!>, :user-pass<abc>, :aes )`
- `:aes` encrypts the document using stronger V4 AES encryption, introduced with PDF 1.6.
Note that it's quite common to leave the user-password blank. This indicates that the document is readable by anyone, but may have restrictions on update, printing or copying of the PDF.
An encrypted PDF can be saved as JSON. It will remain encrypted and passwords may be required, to reopen it.
## Built-in objects
`PDF::COS` also provides a few essential derived classes, that are needed read and write PDF files,
including encryption, object streams and cross reference streams.
*Class* | *Base Class* | *Description*
--- | --- | --- |
PDF | PDF::COS::Dict | document entry point - the trailer dictionary
PDF::COS::Type::Encrypt | PDF::COS::Dict | PDF Encryption/Permissions dictionary
PDF::COS::Type::Info | PDF::COS::Dict | Document Information Dictionary
PDF::COS::Type::ObjStm | PDF::COS::Stream | PDF 1.5+ Object stream (packed indirect objects)
PDF::COS::Type::XRef | PDF::COS::Stream | PDF 1.5+ Cross Reference stream
PDF::COS::TextString | PDF::COS::ByteString | Implements PDF 'text-string' (Unicode) strings
## Further Reading
- [PDF Explained](http://shop.oreilly.com/product/0636920021483.do) By John Whitington (120pp) - Offers an excellent overview of the PDF format.
- [PDF 32000-1:2008 1.7](https://opensource.adobe.com/dc-acrobat-sdk-docs/standards/pdfstandards/pdf/PDF32000_2008.pdf) specification - This is the main reference used in the construction of this module.
## See also
- [PDF::Lite](https://pdf-raku.github.io/PDF-Lite-raku) - basic graphics; including images, fonts, text and general graphics
- [PDF::API6](https://pdf-raku.github.io/PDF-API6) - general purpose PDF manipulation (under construction)
```
|
## dist_cpan-JGOFF-OLE-Storage_Lite.md
```
NAME
OLE::Storage_Lite - Read and Write OLE files on any platform
DESCRIPTION
This module allows you to read and write an OLE-Structured file.
It works anywhere Raku works, without the need of an OLE binary.
REQUIREMENT
Raku 6.c (anything that supports experimental:pack)
INSTALLATION
Using the Zef installer:
zef update
zef install OLE::Storage_Lite
SAMPLE
This still retains the Perl 5 sample scripts, will rewrite these for
proper Raku compatibility later.
smplls.pl : displays PPS structure of specified file
(subset of "lls" distributed with OLE::Storage)
smpsv.pl : creates and save a sample OLE-file(tsv.dat).
ACKNOWLEDGEMENTS
This module is as close to a 1:1 translation of the Perl 5 OLE::Storage_Lite
module as I could reasonably get. All glory belongs to Kawai Takanori, all
new bugs are my fault.
AUTHOR
Jeff Goff
AUTHOR EMERITUS
Kawai Takanori (kwitknr@cpan.org)
```
|
## dist_cpan-FCO-Red.md
[](https://github.com/FCO/Red/actions)
[](https://github.com/FCO/Red/actions)
# Red
Take a look at our Documentation: <https://fco.github.io/Red/>
## Red - A **WiP** ORM for Raku
## INSTALL
Install with (you need **rakudo 2018.12-94-g495ac7c00** or **newer**):
```
zef install Red
```
## SYNOPSIS
```
use Red:api<2>;
model Person {...}
model Post is rw {
has Int $.id is serial;
has Int $!author-id is referencing( *.id, :model(Person) );
has Str $.title is column{ :unique };
has Str $.body is column;
has Person $.author is relationship{ .author-id };
has Bool $.deleted is column = False;
has DateTime $.created is column .= now;
has Set $.tags is column{
:type<string>,
:deflate{ .keys.join: "," },
:inflate{ set(.split: ",") }
} = set();
method delete { $!deleted = True; self.^save }
}
model Person is rw {
has Int $.id is serial;
has Str $.name is column;
has Post @.posts is relationship{ .author-id };
method active-posts { @!posts.grep: not *.deleted }
}
my $*RED-DB = database "SQLite";
Person.^create-table;
```
```
-- Equivalent to the following query:
CREATE TABLE person(
id integer NOT NULL primary key
AUTOINCREMENT,
name varchar(255) NOT NULL
)
```
```
Post.^create-table;
```
```
-- Equivalent to the following query:
CREATE TABLE post(
id integer NOT NULL primary key AUTOINCREMENT,
author_id integer NULL references person(id),
title varchar(255) NOT NULL,
body varchar(255) NOT NULL,
deleted integer NOT NULL,
created varchar(32) NOT NULL,
tags varchar(255) NOT NULL,
UNIQUE (title)
)
```
```
my Post $post1 = Post.^load: :42id;
```
```
-- Equivalent to the following query:
SELECT
post.id,
post.author_id as "author-id",
post.title,
post.body,
post.deleted,
post.created,
post.tags
FROM
post
WHERE
post.id = 42
```
```
my Post $post1 = Post.^load: 42;
```
```
-- Equivalent to the following query:
SELECT
post.id,
post.author_id as "author-id",
post.title,
post.body,
post.deleted,
post.created,
post.tags
FROM
post
WHERE
post.id = 42
```
```
my Post $post1 = Post.^load: :title("my title");
```
```
-- Equivalent to the following query:
SELECT
post.id,
post.author_id as "author-id",
post.title,
post.body,
post.deleted,
post.created,
post.tags
FROM
post
WHERE
post.title = ‘my title’
```
```
my $person = Person.^create: :name<Fernando>;
```
```
-- Equivalent to the following query:
INSERT INTO person(
name
)
VALUES(
?
)
-- BIND: ["Fernando"]
-- SQLite needs an extra select:
SELECT
person.id,
person.name
FROM
person
WHERE
_rowid_ = last_insert_rowid()
LIMIT 1
```
```
RETURNS:
Person.new(name => "Fernando")
```
```
# Using Pg Driver for this block
{
my $*RED-DB = database "Pg";
my $person = Person.^create: :name<Fernando>;
}
```
```
-- Equivalent to the following query:
INSERT INTO person(
name
)
VALUES(
$1
) RETURNING *
-- BIND: ["Fernando"]
```
```
RETURNS:
Person.new(name => "Fernando")
```
```
say $person.posts;
```
```
-- Equivalent to the following query:
SELECT
post.id,
post.author_id as "author-id",
post.title,
post.body,
post.deleted,
post.created,
post.tags
FROM
post
WHERE
post.author_id = ?
-- BIND: [1]
```
```
say Person.new(:2id)
.active-posts
.grep: { .created > now }
```
```
-- Equivalent to the following query:
SELECT
post.id,
post.author_id as "author-id",
post.title,
post.body,
post.deleted,
post.created,
post.tags
FROM
post
WHERE
(
post.author_id = ?
AND (
post.deleted == 0
OR post.deleted IS NULL
)
)
AND post.created > 1554246698.448671
-- BIND: [2]
```
```
my $now = now;
say Person.new(:3id)
.active-posts
.grep: { .created > $now }
```
```
-- Equivalent to the following query:
SELECT
post.id,
post.author_id as "author-id",
post.title,
post.body,
post.deleted,
post.created,
post.tags
FROM
post
WHERE
(
post.author_id = ?
AND (
post.deleted == 0
OR post.deleted IS NULL
)
)
AND post.created > ?
-- BIND: [
-- 3,
-- Instant.from-posix(
-- <399441421363/257>,
-- Bool::False
-- )
-- ]
```
```
Person.^create:
:name<Fernando>,
:posts[
{
:title("My new post"),
:body("A long post")
},
]
;
```
```
-- Equivalent to the following query:
INSERT INTO person(
name
)
VALUES(
?
)
-- BIND: ["Fernando"]
SELECT
person.id,
person.name
FROM
person
WHERE
_rowid_ = last_insert_rowid()
LIMIT 1
-- BIND: []
INSERT INTO post(
created,
title,
author_id,
tags,
deleted,
body
)
VALUES(
?,
?,
?,
?,
?,
?
)
-- BIND: [
-- "2019-04-02T22:55:13.658596+01:00",
-- "My new post",
-- 1,
-- "",
-- Bool::False,
-- "A long post"
-- ]
SELECT
post.id,
post.author_id as "author-id",
post.title,
post.body,
post.deleted,
post.created,
post.tags
FROM
post
WHERE
_rowid_ = last_insert_rowid()
LIMIT 1
```
```
my $post = Post.^load: :title("My new post");
```
```
-- Equivalent to the following query:
SELECT
post.id,
post.author_id as "author-id",
post.title,
post.body,
post.deleted,
post.created,
post.tags
FROM
post
WHERE
post.title = ‘My new post’
-- BIND: []
```
```
RETURNS:
Post.new(
title => "My new post",
body => "A long post",
deleted => 0,
created => DateTime.new(
2019,
4,
2,
23,
7,
46.677388,
:timezone(3600)
),
tags => Set.new("")
)
```
```
say $post.body;
```
```
PRINTS:
A long post
```
```
my $author = $post.author;
```
```
RETURNS:
Person.new(name => "Fernando")
```
```
$author.name = "John Doe";
$author.^save;
```
```
-- Equivalent to the following query:
UPDATE person SET
name = ‘John Doe’
WHERE id = 1
```
```
$author.posts.create:
:title("Second post"),
:body("Another long post");
```
```
-- Equivalent to the following query:
INSERT INTO post(
title,
body,
created,
tags,
deleted,
author_id
)
VALUES(
?,
?,
?,
?,
?,
?
)
-- BIND: [
-- "Second post",
-- "Another long post",
-- "2019-04-02T23:28:09.346442+01:00",
-- "",
-- Bool::False,
-- 1
-- ]
```
```
$author.posts.elems;
```
```
-- Equivalent to the following query:
SELECT
count(*) as "data_1"
FROM
post
WHERE
post.author_id = ?
-- BIND: [1]
```
```
RETURNS:
2
```
## DESCRIPTION
Red is a *WiP* ORM for Raku.
### traits
* `is column`
* `is column{}`
* `is id`
* `is id{}`
* `is serial`
* `is referencing{}`
* `is relationship{}`
* `is table<>`
* `is nullable`
### features:
#### relationships
Red will infer relationship data if you use type constraints on your properties.
```
# Single file e.g. Schema.pm6
model Related { ... }
# belongs to
model MyModel {
has Int $!related-id is referencing( *.id, :model<Related> );
has Related $.related is relationship{ .id };
}
# has one/has many
model Related {
has Int $.id is serial;
has MyModel @.my-models is relationship{ .related-id };
}
```
If you want to put your schema into multiple files, you can create an "indirect" relationship, and Red will look up the related models as necessary.
```
# MyModel.pm6
model MyModel {
has Int $!related-id is referencing{ :model<Related>, :column<id> };
has $.related is relationship({ .id }, :model<Related>);
}
# Related.pm6
model Related {
has Int $.id is serial;
has @.my-models is relationship({ .related-id }, :model<MyModel>);
}
```
If Red can’t find where your `model` is defined you can override where it looks with `require`:
```
has Int $!related-id is referencing{ :model<Related>, :column<id>,
:require<MyApp::Schema::Related> };
```
#### custom table name
```
model MyModel is table<custom_table_name> {}
```
#### not nullable columns by default
Red, by default, has not nullable columns, to change it:
```
#| This makes this model’s columns nullable by default
model MyModel is nullable {
has Int $.col1 is column; #= this column is nullable
has Int $.col2 is column{ :!nullable }; #= this one is not nullable
}
```
#### load object from database
```
MyModel.^load: 42;
MyModel.^load: id => 42;
```
#### save object on the database
```
$object.^save;
```
#### search for a list of object
```
Question.^all.grep: { .answer == 42 }; # returns a result seq
```
#### phasers
* `before-create`
* `after-create`
* `before-update`
* `after-update`
* `before-delete`
* `after-delete`
#### Temporary table
```
model Bla is temp { ... }
```
#### Create table
```
Question.^create-table;
Question.^create-table: :if-not-exists;
Question.^create-table: :unless-exists;
```
#### IN
```
Question.^all.grep: *.answer ⊂ (3.14, 13, 42)
```
#### create
```
Post.^create: :body("bla ble bli blo blu"), :title("qwer");
model Tree {
has UInt $!id is id;
has Str $.value is column;
has UInt $!parent-id is referencing{ Tree.id };
has Tree $.parent is relationship{ .parent-id };
has Tree @.kids is relationship{ .parent-id };
}
Tree.^create-table: :if-not-exists;
Tree.^create:
:value<Bla>,
:parent{:value<Ble>},
:kids[
{:value<Bli>},
{:value<Blo>},
{:value<Blu>}
]
;
```
## AUTHOR
Fernando Correa de Oliveira [fernandocorrea@gmail.com](mailto:fernandocorrea@gmail.com)
## COPYRIGHT AND LICENSE
Copyright 2018 Fernando Correa de Oliveira
This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.
|
## coercion-20type.md
Coercion type
Combined from primary sources listed below.
# [In Signature literals](#___top "go to top of document")[§](#(Signature_literals)_Coercion_type_Coercion_type "direct link")
See primary documentation
[in context](/language/signatures#Coercion_type)
for **Coercion type**.
To accept one type but coerce it automatically to another, use the accepted type as an argument to the target type. If the accepted type is [`Any`](/type/Any) it can be omitted.
```raku
sub f(Int(Str) $want-int, Str() $want-str) {
say $want-int.^name ~ ' ' ~ $want-str.^name
}
f '10', 10;
# OUTPUT: «Int Str»
sub foo(Date(Str) $d) { say $d.^name; say $d };
foo "2016-12-01";
# OUTPUT: «Date2016-12-01»
```
The coercion is performed by calling the method with the name of the type to coerce to, if it exists. In this example, we're calling the builtin method [`Date`](/type/Date) on the [`Str`](/type/Str) class. The method is assumed to return the correct type—no additional checks on the result are currently performed.
Coercion can also be performed on return types:
```raku
sub square-str (Int $x --> Str(Int)) {
$x²
}
for 2,4, *² … 256 -> $a {
say $a, "² is ", square-str( $a ).chars, " figures long";
}
# OUTPUT: «2² is 1 figures long
# 4² is 2 figures long
# 16² is 3 figures long
# 256² is 5 figures long»
```
In this example, coercing the return type to [`Str`](/type/Str) allows us to directly apply string methods, such as the number of characters.
**Note**: The appropriate method must be available on the argument, so be careful when trying to coerce custom types.
```raku
class Foo { }
sub bar(Foo(Int) $x) { say $x }
bar(3);
# OUTPUT: «Impossible coercion from 'Int' into 'Foo': no acceptable coercion method found»
```
|
## syntax.md
role X::Syntax
Syntax error thrown by the compiler
```raku
role X::Syntax does X::Comp { }
```
Common role for syntax errors thrown by the compiler.
|
## dist_cpan-NINE-CompUnit-Repository-Mask.md
[](https://travis-ci.org/niner/CompUnit-Repository-Mask)
# NAME
CompUnit::Repository::Mask - hide installed modules for testing.
# SYNOPSIS
```
use CompUnit::Repository::Mask :mask-module, :unmask-module;
mask-module('Test');
try require Test; # now fails
unmask-module('Test');
require Test; # succeeds
```
# DESCRIPTION
CompUnit::Repository::Mask helps testing code dealing with optional dependencies. It allows for masking and unmasking installed modules, so you can write tests for when the dependency is missing and for when it's installed.
# AUTHOR
Stefan Seifert [nine@detonation.org](mailto:nine@detonation.org)
# COPYRIGHT AND LICENSE
Copyright 2017 Stefan Seifert
This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.
|
## dist_github-marcoonroad-CUID.md
# CUID
CUID generator for Perl 6.
[](https://travis-ci.org/marcoonroad/perl6-cuid)
### Description
Once CPU power and host machines are increased, UUIDs become prone
to collisions. To avoid such collisions, developers often resort to
database round trips just to check/detect a possible collision, and
thus, perform a new ID generation which doesn't collide. But nowadays,
databases are the major software bottleneck of our services, and that
round trips are too expensive (we lost scalability a lot)!
CUIDs are a solution for that sort of problem. Due the monotonically
increasing nature, we can also leverage that to improve database performance
(most specifically, dealing with primary keys). CUIDs contain host machine
fingerprints to avoid ID collision among the network nodes, and they could even work
generating CUIDs offline without any problem.
For more information, see: <http://usecuid.org>
### Important Notes
> This library is thread-safe regarding internal state counter.
### Installation
Inside this root directory project, just type:
```
$ zef --force install .
```
As an alternative, you could type as well:
```
$ make install
```
### Usage
To generate full CUIDs, use the `cuid` function:
```
use CUID;
my $cuid = cuid( );
$cuid.say; # ===> c1xyr5kms0000qb8qtlakvjsj
```
For slugs (short and weak CUIDs), use the following `cuid-slug` function:
```
use CUID;
my $cuid-slug = cuid-slug( );
$cuid-slug.say; # ===> f900qqno
```
### Final Notes
Happy hacking, kiddo!
|
## dist_zef-dwarring-PDF-Native.md
[[Raku PDF Project]](https://pdf-raku.github.io)
/ [PDF::Native](https://pdf-raku.github.io/PDF-Native-raku)
# PDF::Native
## Description
This module provides a selection of native implementations of
PDF parsing and functions.
Just installing this module provides an increase in performance,
which is most noticeable when reading or writing larger PDF files.
So far, the areas covered are:
* parsing of native (COS) objects by PDF::IO::Reader
* parsing and serialization of graphics by PDF::Content::Ops
* the PDF::IO::Filter::Predictor `decode` and `encode` functions.
* the widely used PDF::IO::Util `pack` and `unpack` functions.
* reading of cross reference tables and PDF 1.5+ cross reference streams.
* writing of strings, numerics, cross-reference tables and streams.
## Classes in this Distribution
* [PDF::Native::COS](https://pdf-raku.github.io/PDF-Native-raku/PDF/Native/COS)
* [PDF::Native::Filter::Predictors](https://pdf-raku.github.io/PDF-Native-raku/PDF/Native/Filter/Predictors)
* [PDF::Native::Buf](https://pdf-raku.github.io/PDF-Native-raku/PDF/Native/Buf)
* [PDF::Native::Reader](https://pdf-raku.github.io/PDF-Native-raku/PDF/Native/Reader)
* [PDF::Native::Writer](https://pdf-raku.github.io/PDF-Native-raku/PDF/Native/Writer)
## Todo
Some other areas under consideration:
* C equivalents for other PDF::IO::Filter encoding functions, including predictors, ASCII-Hex, ASCII-85 and run-length encoding
* Support for type-1 character transcoding (PDF::Content::Font::Enc::Glyphic)
* Support for PDF::Content::Image, including color-channel separation and (de)multiplexing. GIF decompression de-interlacing.
There's sure to be others.
Currently giving noticeable benefits on larger PDFs.
|
## dist_zef-raku-community-modules-Spreadsheet-XLSX.md
[](https://github.com/raku-community-modules/Spreadsheet-XLSX/actions)
# NAME
Spreadsheet::XLSX - blah blah blah
# DESCRIPTION
A Raku module for working with Excel spreadsheets (XLSX format), both reading existing files, creating new files, or modifying existing files and saving the changes. Of note, it:
* Knows how to lazily load sheet content, so if you don't look at a sheet then time won't be spent deserializing it (down to a cell level, even)
* In the modification scenario, tries to leave as much intact as it can, meaning that it's possible to poke data into a sheet more complex than could be produced by the module from scratch
* Only depends on the Raku `LibXML` and `Libarchive` modules (and their respective native dependencies)
This module is currently in development, and supports the subset of XLSX format features that were immediately needed for the use-case it was built for. That isn't so much, for now, but it will handle the most common needs:
* Enumerating worksheets
* Reading text and numbers from cells on a worksheet
* Creating new workbooks with worksheets with text and number cells
* Setting basic styles and number formats on cells in newly created worksheets
* Reading a workbook, making modifications, and saving it again
* Reading and writing column properties (such as column width)
# SYNOPSIS
## Reading existing workbooks
```
use Spreadsheet::XLSX;
# Read a workbook from an existing file (can pass IO::Path or a
# Blob in the case it was uploaded).
my $workbook = Spreadsheet::XLSX.load('accounts.xlsx');
# Get worksheets.
say "Workbook has {$workbook.worksheets.elems} sheets";
# Get the name of a worksheet.
say $workbook.worksheets.name;
# Get cell values (indexing is zero-based, done as a multi-dimensional array
# indexing operation [row ; column].
my $cells = $workbook.worksheets[0].cells;
say .value with $cells[0;0]; # A1
say .value with $cells[0;1]; # B1
say .value with $cells[1;0]; # A2
say .value with $cells[1;1]; # B2
```
## Creating new workbooks
```
use Spreadsheet::XLSX;
# Create a new workbook and add some worksheets to it.
my $workbook = Spreadsheet::XLSX.new;
my $sheet-a = $workbook.create-worksheet('Ingredients');
my $sheet-b = $workbook.create-worksheet('Matching Drinks');
# Put some data into a worksheet and style it. This is how the model
# actually works (useful if you want to add styles later).
$sheet-a.cells[0;0] = Spreadsheet::XLSX::Cell::Text.new(value => 'Ingredient');
$sheet-a.cells[0;0].style.bold = True;
$sheet-a.cells[0;1] = Spreadsheet::XLSX::Cell::Text.new(value => 'Quantity');
$sheet-a.cells[0;1].style.bold = True;
$sheet-a.cells[1;0] = Spreadsheet::XLSX::Cell::Text.new(value => 'Eggs');
$sheet-a.cells[1;1] = Spreadsheet::XLSX::Cell::Number.new(value => 6);
$sheet-a.cells[1;1].style.number-format = '#,###';
# However, there is a convenience form too.
$sheet-a.set(0, 0, 'Ingredient', :bold);
$sheet-a.set(0, 1, 'Quantity', :bold);
$sheet-a.set(1, 0, 'Eggs');
$sheet-a.set(1, 1, 6, :number-format('#,###'));
# Save it to a file (string or IO::Path name).
$workbook.save("foo.xlsx");
# Or get it as a blob, e.g. for a HTTP response.
my $blob = $workbook.to-blob();
```
# Class / Method reference
## class Spreadsheet::XLSX
The actual outward facing class
### has Hash $!archive
Map of files in the decompressed archive we read from, if any.
### has Spreadsheet::XLSX::ContentTypes $.content-types
The content types of the workbook.
### has Associative[Spreadsheet::XLSX::Relationships] %!relationships
Map of loaded relationships for paths. (Those never used are not in here.)
## class Attribute+{<anon|2>}.new(handles => $("create-worksheet", "worksheets", "shared-strings", "styles"))
The workbook itself.
### has Spreadsheet::XLSX::DocProps::Core $!core-props
Document Core Properties
### multi method load
```
multi method load(
Str $file
) returns Spreadsheet::XLSX
```
Load an Excel workbook from the file path identified by the given string.
### multi method load
```
multi method load(
IO::Path $file
) returns Spreadsheet::XLSX
```
Load an Excel workbook in the specified file.
### multi method load
```
multi method load(
Blob $content
) returns Spreadsheet::XLSX
```
Load an Excel workbook from the specified blob. This is useful in the case it was sent over the network, and so never written to disk.
### method find-relationships
```
method find-relationships(
Str $path,
Bool :$create = Bool::False
) returns Spreadsheet::XLSX::Relationships
```
Get the relationships for a given path in the XLSX archive.
### method get-file-from-archive
```
method get-file-from-archive(
Str $path
) returns Blob
```
Obtain a file from the archive. Will fail if we are not backed by an archive, or if there is no such file.
### method set-file-in-archive
```
method set-file-in-archive(
Str $path,
Blob $content
) returns Nil
```
Set the content of a file in the archive, replacing any existing content.
### method to-blob
```
method to-blob() returns Blob
```
Serializes the current state of the spreadsheet into XLSX format and returns a Blob containing it.
### multi method save
```
multi method save(
Str $file
) returns Nil
```
Saves the Excel workbook to the file path identified by the given string.
### multi method save
```
multi method save(
IO::Path $file
) returns Nil
```
Save an Excel workbook to the specified file.
### method sync-to-archive
```
method sync-to-archive() returns Nil
```
Synchronizes all changes to the internal representation of the archive. This is performed automatically before saving, and there is no need to explicitly perform it.
# CREDITS
Thanks goes to [Agrammon](https://agrammon.ch/) for making the development of this module possible.
# AUTHOR
Jonathan Worthington
# COPYRIGHT AND LICENSE
Copyright 2020 - 2024 Jonathan Worthington
Copyright 2024 Raku Community
This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.
|
## dist_github-ufobat-HTTP-Server-Ogre.md
[](https://travis-ci.org/ufobat/HTTP-Server-Ogre)
# NAME
HTTP::Server::Ogre
# SYNOPSIS
```
use HTTP::Server::Ogre;
```
# DESCRIPTION
HTTP::Server::Ogre is not tiny nor easy to handle. He is rather a stupid ogre that handles parallel http requests
# AUTHOR
Martin Barth [martin@senfdax.de](mailto:martin@senfdax.de)
# SEE ALSO
Cro especially Cro::HTTP - <https://github.com/croservices/cro-http>
# ACKNOWLEDGEMENTS
Thanks to the guys from Cro, especially Jonathan and Altai-man for writing the first HTTP/2 Implementation.
# COPYRIGHT AND LICENSE
Copyright 2017 Martin Barth
This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.
|
## parts.md
class IO::Path::Parts
IO::Path parts encapsulation
```raku
class IO::Path::Parts does Positional does Associative does Iterable { }
```
An `IO::Path::Parts` object is a container for the parts of an [`IO::Path`](/type/IO/Path) object. It is usually created with a call to the method [`.parts`](/type/IO/Path#method_parts) on an [`IO::Path`](/type/IO/Path) object. It can also be created with a call to the method [`.split`](/routine/split) on an object of one of the low-level path operations sub-classes of [`IO::Spec`](/type/IO/Spec).
The parts of an [`IO::Path`](/type/IO/Path) are:
* the volume, see [`.volume`](/type/IO/Path#method_volume)
* the directory name, see [`.dirname`](/type/IO/Path#method_dirname)
* the basename, see [`.basename`](/type/IO/Path#method_basename)
# [Methods](#class_IO::Path::Parts "go to top of document")[§](#Methods "direct link")
## [method new](#class_IO::Path::Parts "go to top of document")[§](#method_new "direct link")
```raku
method new(\volume, \dirname, \basename)
```
Create a new `IO::Path::Parts` object with `\volume`, `\dirname` and `\basename` as respectively the volume, directory name and basename parts.
## [attribute volume](#class_IO::Path::Parts "go to top of document")[§](#attribute_volume "direct link")
Read-only. Returns the volume of the `IO::Path::Parts` object.
```raku
IO::Path::Parts.new('C:', '/some/dir', 'foo.txt').volume.say;
# OUTPUT: «C:»
```
## [attribute dirname](#class_IO::Path::Parts "go to top of document")[§](#attribute_dirname "direct link")
Read-only. Returns the directory name part of the `IO::Path::Parts` object.
```raku
IO::Path::Parts.new('C:', '/some/dir', 'foo.txt').dirname.say;
# OUTPUT: «/some/dir»
```
## [attribute basename](#class_IO::Path::Parts "go to top of document")[§](#attribute_basename "direct link")
Read-only. Returns the basename part of the `IO::Path::Parts` object.
```raku
IO::Path::Parts.new('C:', '/some/dir', 'foo.txt').basename.say;
# OUTPUT: «foo.txt»
```
# [Previous implementations](#class_IO::Path::Parts "go to top of document")[§](#Previous_implementations "direct link")
Before Rakudo 2020.06 the `.parts` method of [`IO::Path`](/type/IO/Path) returned a [`Map`](/type/Map) and the `.split` routine of the [`IO::Spec`](/type/IO/Spec) sub-classes returned a [`List`](/type/List) of [`Pair`](/type/Pair). The `IO::Path::Parts` class maintains compatibility with these previous implementations by doing [`Positional`](/type/Positional), [`Associative`](/type/Associative) and [`Iterable`](/type/Iterable).
```raku
my $parts = IO::Path::Parts.new('C:', '/some/dir', 'foo.txt');
say $parts<volume>; # OUTPUT: «C:»
say $parts[0]; # OUTPUT: «volume => C:»
say $parts[0].^name; # OUTPUT: «Pair»
.say for $parts[];
# OUTPUT: «volume => C:dirname => /some/dirbasename => foo.txt»
```
|
## flip.md
flip
Combined from primary sources listed below.
# [In Str](#___top "go to top of document")[§](#(Str)_routine_flip "direct link")
See primary documentation
[in context](/type/Str#routine_flip)
for **routine flip**.
```raku
multi flip(Str:D --> Str:D)
multi method flip(Str:D: --> Str:D)
```
Returns the string reversed character by character.
Examples:
```raku
"Raku".flip; # OUTPUT: «ukaR»
"ABBA".flip; # OUTPUT: «ABBA»
```
# [In Allomorph](#___top "go to top of document")[§](#(Allomorph)_method_flip "direct link")
See primary documentation
[in context](/type/Allomorph#method_flip)
for **method flip**.
```raku
method flip(Allomorph:D:)
```
Calls [`Str.flip`](/type/Str#routine_flip) on the invocant's [`Str`](/type/Str) value.
# [In Cool](#___top "go to top of document")[§](#(Cool)_routine_flip "direct link")
See primary documentation
[in context](/type/Cool#routine_flip)
for **routine flip**.
```raku
sub flip(Cool $s --> Str:D)
method flip()
```
Coerces the invocant (or in sub form, its argument) to [`Str`](/type/Str), and returns a reversed version.
```raku
say 421.flip; # OUTPUT: «124»
```
|
## dist_zef-tony-o-HTTP-Server-Router.md
# Perl6's HTTP Router for the Pros
[](https://travis-ci.org/tony-o/perl6-http-server-router)
This here module provides a routing system for use with `HTTP::Server::Async`. It can accept named parameters (currently no restraints on what the parameter is), and hard typed paths. Check out below for examples and usage.
## Usage
```
use HTTP::Server::Async;
use HTTP::Server::Router;
my HTTP::Server::Async $server .=new;
serve $server;
route '/', sub($req, $res) {
$res.close('Hello world!');
}
route '/:whatever', sub($req, $res) {
$res.close($req.params<whatever>);
}
route / .+ /, sub($req, $res) {
$res.status = 404;
$res.close('Not found.');
}
$server.listen(True);
```
The example above matches a route '/' and response 'Hello world!' (complete with headers). The other route that matches is '/' and it echos `<anything>` back to the client. All other connections will hang until the client times them out.
## Notes
Routes are called in the order they're registered. If the route's sub returns a promise, no further processing is done until that Promise is kept/broken. If the route's sub does *not* return a Promise then a `True` (or anything that indicates True) value indicates that further processing should stop. A `False` value means continue trying to match handlers.
## License
Do what you will. Be careful out there amongst the English.
@tony-o
|
## dist_zef-lizmat-Scalar-Util.md
[](https://github.com/lizmat/Scalar-Util/actions)
# NAME
Raku port of Perl's Scalar::Util module 1.55
# SYNOPSIS
```
use Scalar::Util <blessed dualvar isdual readonly refaddr reftype
isvstring looks_like_number openhandle>
```
# DESCRIPTION
This module tries to mimic the behaviour of Perl's `Scalar::Util` module as closely as possible in the Raku Programming Language.
`Scalar::Util` contains a selection of subroutines that people have expressed would be nice to have in the perl core, but the usage would not really be high enough to warrant the use of a keyword, and the size would be so small that being individual extensions would be wasteful.
By default `Scalar::Util` does not export any subroutines.
## blessed
```
my $class = blessed( $object );
```
Returns the name of the class of the object.
## refaddr
```
my $addr = refaddr( $object );
```
Returns the internal memory address of the object as a plain integer. Please note that Raku implementations do **not** require the memory address of an object to be constant: in fact, with `MoarVM` as a back end, any longer living object **will** have its memory address changed over its lifetime.
## reftype
```
my $type = reftype( $object );
```
For objects performing the `Positional` role, `ARRAY` will be returned. For objects performing the `Associative` role, `HASH` will be returned. Otherwise `Nil` will be returned.
## dualvar
```
my $var = dualvar( $num, $string );
```
Returns a scalar that has the value `$num` when used as a number and the value `$string` when used as a string.
```
$foo = dualvar 10, "Hello";
$num = $foo + 2; # 12
$str = $foo . " world"; # Hello world
```
## isdual
```
my $dual = isdual( $var );
```
If `$var` is a scalar that has both numeric and string values, the result is true.
```
$foo = dualvar 86, "Nix";
$dual = isdual($foo); # True
```
## isvstring
```
my $vstring = isvstring( $var );
```
Returns whether `$var` is a `Version` object.
```
$vs = v49.46.48;
$isver = isvstring($vs); # True
```
## looks\_like\_number
```
my $isnum = looks_like_number( $var );
```
Returns true if `$var` can be coerced to a number.
## readonly
```
my $ro = readonly( $var );
```
Returns true if `$var` is readonly (aka does not have a container).
```
sub foo(\value) { readonly(value) }
$readonly = foo($bar); # False
$readonly = foo(0); # True
```
## openhandle
```
my $fh = openhandle( $fh );
Returns $fh itself if $fh may be used as a filehandle and is open, or is
is a tied handle. Otherwise <Nil> is returned.
$fh = openhandle($*STDIN);
$fh = openhandle($notopen); # Nil
$fh = openhandle("scalar"); # Nil
```
# FUNCTIONS NOT PORTED
It did not make sense to port the following functions to Raku, as they pertain to specific Pumpkin Perl internals.
```
weaken isweak unweaken set_prototype tainted
```
Attempting to import these functions will result in a compilation error with hopefully targeted feedback. Attempt to call these functions using the fully qualified name (e.g. `Scalar::Util::weaken($a)`) will result in a run time error with the same feedback.
# SEE ALSO
List::Util
# AUTHOR
Elizabeth Mattijsen [liz@raku.rocks](mailto:liz@raku.rocks)
Source can be located at: <https://github.com/lizmat/Scalar-Util> . Comments and Pull Requests are welcome.
# COPYRIGHT AND LICENSE
Copyright 2018, 2019, 2020, 2021 Elizabeth Mattijsen
This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.
Re-imagined from the Perl version as part of the CPAN Butterfly Plan. Perl version originally developed by Graham Barr, subsequently maintained by Matthijs van Duin, cPanel and Paul Evans.
|
## dist_zef-lizmat-ParaSeq.md
## Chunk 1 of 2
[](https://github.com/lizmat/ParaSeq/actions) [](https://github.com/lizmat/ParaSeq/actions) [](https://github.com/lizmat/ParaSeq/actions)
# NAME
ParaSeq - Parallel execution of Iterables
# SYNOPSIS
```
use ParaSeq;
# The 1-millionth prime number: 15485863
say (^Inf).&hyperize.grep(*.is-prime)[999999];
say (^Inf).&hyperize.grep(*.is-prime).skip(999999).head;
# Fetching lines of files, each element containing a List of lines
my @lines = @filenames.&hyperize(1, :!auto).map(*.IO.lines.List);
my %lines = @filenames.&racify(1, :!auto).map: { $_ => .IO.lines.List }
```
# DESCRIPTION
ParaSeq provides the functional equivalent of [`hyper`](https://docs.raku.org/type/Iterable#method_hyper) and [`race`](https://docs.raku.org/type/Iterable#method_race), but re-implemented from scratch with all of the experience from the initial implementation of `hyper` and `race` in 2014, and using features that have since been added to the Raku Programming Language.
As such it exports two subroutines `hyperize` and `racify`, to make them plug-in compatible with the [`hyperize`](https://raku.land/zef:lizmat/hyperize) distribution.
## STATUS
This module is now considered to be in BETA, as all features mentioned in the [IMPROVEMENTS](#IMPROVEMENTS) section have been implemented.
# SUBROUTINES
## hyperize
```
# The 1-millionth prime number using subroutine syntax: 15485863
say hyperize(^Inf).grep(*.is-prime)[999999];
# Start with 2000 element batches, and use max 10 workers
say (^Inf).&hyperize(2000, 10).grep(*.is-prime)[999999];
# Always work with a batch-size of 1
my @lines = @filenames.&hyperize(1, :!auto).map(*.lines.List);
```
Change the given `Iterable` into a `ParaSeq` object if the following conditions have been met:
* degree is more than 1
If the number of simultaneous workers is set to 1, there is no real parallelizetion possible. In which case `hyperize` will simply return its first argument (the invocant when used with the `.&hyperize` syntax).
* source is not exhausted with first batch
If the first batch already exhausts the source iterator, then there is little point in parallelizing. A `Seq` that will reproduce the original source sequence will then be returned.
### ARGUMENTS
* source
The first positional argument indicates the `Iterable` source of values to be processed. If the `.&hyperize` syntax is used, this is the invocant.
* initial batch size
The second positional argument indicates the initial batch size to be used. It defaults to `16`. Will also assume the default if an undefined value is specified.
* maximum number of simultaneous workers
The third positional argument indicates the maximum number of worker threads that can be activated to process the values of the source. It defaults to the number of available CPUs minus 1. Will also assume the defailt if an undefined value is specified.
* :auto / :!auto
Flag. Defaults to `True`. If specified with a `False` value, then the batch size will **not** be altered from the size (implicitely) specified with the second positional argument.
* :catch / :!catch
Flag. Defaults to `True`. If specified with a `False` value, then any exception that is thrown by any of the parallel worker threads, will be re-thrown immediately, rather than being presented on STDERR at the end of the process.
## racify
```
my %lines = @filenames.&racify(1, :!auto).map: { $_ => .IO.lines.List }
```
There is very little functional difference between `hyperize` and `racify`. The only difference is that while `hyperize` will guarantee that the order of the produced values is the same as their source values, `racify` does **not** offer such a guarantee.
From a performance point of view, `racify` **may** be a few percent faster than `hyperize`, but one should generally not use it for that reason.
One situation to use `racify` over `hyperize` is when any results are expected as soon as they become available, without waiting for any results from a previous batch being delivered.
One should also note that the use of the `last` statement in a `grep` or `map` may produce random results, as delivery of produced values is halted after the batch that was produced while the `last` statement was executed, has been delivered.
# ENDPOINT METHODS
These methods return a single value that could be considered a reduction of the hypered iteration. In alphabetical order:
## are
Because the [`.are`](https://docs.raku.org/type/Any#method_are) method is already **highly** optimized, adding specific hypering would only slow down execution. So no specific hypering support has been added.
## categorize
Because the [`.categorize`](https://docs.raku.org/type/List#routine_categorize) method produces a Hash, putting together the `Hash` results of each batch in a correct manner, would be very complicated and potentially CPU intensive. Therefore, **no** specific hypering logic has been added for this method at this point.
## classify
Because the [`.classify`](https://docs.raku.org/type/List#routine_classify) method produces a Hash, putting together the `Hash` results of each batch in a correct manner, would be very complicated and potentially CPU intensive. Therefore, **no** specific hypering logic has been added for this method at this point.
## elems
An optimized version of the [`.elems`](https://docs.raku.org/type/List#routine_elems) method has been implemented.
## end
An optimized version of the [`.end`](https://docs.raku.org/type/List#routine_end) method has been implemented.
## first
The [`.first`](https://docs.raku.org/type/List#routine_first) method is supported without any specific hypering support added as it turned out to be impossible to make it faster.
## head
An optimized version of the [`.head`](https://docs.raku.org/type/List#method_head) method without any arguments (as an endpoint), has been implemented.
## join
An optimized version of the [`.join`](https://docs.raku.org/type/List#routine_join) method has been implemented.
## max
The [`.max`](https://docs.raku.org/type/Any#routine_max) method, when called **without** any named arguments, provides the maximum value without any specific hypering.
## min
The [`.min`](https://docs.raku.org/type/Any#routine_min) method, when called **without** any named arguments, provides the minimum value without any specific hypering.
## minmax
An optimized version of the [`.minmax`](https://docs.raku.org/type/Any#routine_minmax) method has been implemented.
## reduce
An optimized version of the [`.reduce`](https://docs.raku.org/type/List#routine_reduce) method has been implemented.
**Caveat**: will only produce the correct results if the order of the values is **not** important to determine the final result.
## sum
An optimized version of the [`.sum`](https://docs.raku.org/type/List#routine_sum) method has been implemented.
## tail
An optimized version of the [`.tail`](https://docs.raku.org/type/List#method_tail) method without any arguments (as an endpoint), has been implemented.
# INTERFACE METHODS
These methods produce another `ParaSeq` object that will keep the parallelization information so that the possibility for parallelization is used whenever possible.
In alphabetical order:
## antipairs
An optimized version of the [`.antipairs`](https://docs.raku.org/type/List#routine_antipairs) method has been implemented.
## batch
An optimized version of the [`.batch`](https://docs.raku.org/type/List#method_batch) method has been implemented.
## collate
The nature of the [`.collate`](https://docs.raku.org/type/Any#method_collate) method basically makes it impossible to hyper. Therefore, **no** specific hypering logic has been added for this method.
## combinations
The nature of the [`.combinations`](https://docs.raku.org/type/List#routine_combinations) method basically makes it impossible to hyper. Therefore, **no** specific hypering logic has been added for this method.
## deepmap
An optimized version of the [`.deepmap`](https://docs.raku.org/type/Any#method_deepmap) method has been implemented.
**Caveat**: to catch any execution of `last`, the `ParaSeq` module exports its own `last` subroutine. This means that any mapper code will either have to live within the scope in which the `use ParaSeq` command is executed, to ensure proper `last` handling in a hypered `.deepmap`.
## duckmap
An optimized version of the [`.duckmap`](https://docs.raku.org/type/Any#method_duckmap) method has been implemented.
**Caveat**: to catch any execution of `last`, the `ParaSeq` module exports its own `last` subroutine. This means that any mapper code will either have to live within the scope in which the `use ParaSeq` command is executed, to ensure proper `last` handling in a hypered `.duckmap`.
**Caveat**: due to the way `duckmap` was implemented before the `2024.06` release of Rakudo, the `LEAVE` phaser would get called for every value attempted. This has since been fixed, so that the `ENTER` and `LEAVE` phasers are only called if the `Callable` is actually invoked.
## flat
The [`.flat`](https://docs.raku.org/type/Any#method_flat) method is already very simple, and adding hypering overhead would do just that: add overhead. Therefore, **no** specific hypering logic has been added for this method.
## flatmap
No specific support for the [`.flatmap`](https://docs.raku.org/type/List#method_flatmap) method has been added, as its core implementation will do the right thing on `ParaSeq` objects as well.
## grep
An optimized version of the [`.grep`](https://docs.raku.org/type/List#routine_grep) method has been implemented.
**Caveat**: if a `last` statement is executed, it will ensure that no further values will be delivered. However, this may not stop other threads immediately. So any other phasers, such as `ENTER`, and `LEAVE` may still get executed, even though the values that were produced, will not be delivered.
**Caveat**: to catch any execution of `last`, the `ParaSeq` module exports its own `last` subroutine. This means that any matcher code will either have to live within the scope in which the `use ParaSeq` command is executed, to ensure proper `last` handling in a hypered `.grep`.
## head
The [`.head`](https://docs.raku.org/type/List#method_head) method is already very simple, and adding hypering overhead would do just that: add overhead. Therefore, **no** specific hypering logic has been added for this method.
## invert
The nature of the [`.invert`](https://docs.raku.org/type/List#routine_invert) method basically makes it impossible to hyper. Therefore, **no** specific hypering logic has been added for this method.
## keys
The [`.keys`](https://docs.raku.org/type/List#routine_keys) method is already very simple, and adding hypering overhead would do just that: add overhead. Therefore, **no** specific hypering logic has been added for this method.
## kv
An optimized version of the [`.kv`](https://docs.raku.org/type/List#routine_kv) method has been implemented.
## map
An optimized version of the [`.map`](https://docs.raku.org/type/List#routine_map) method has been implemented.
**Caveat**: due to a bug in Rakudo until 2024.06 release, any `FIRST` phaser will be run at the start of each batch. This can be worked around by using the [**$**, the nameless state variable](https://docs.raku.org/language/variables#The_$_variable):
```
@am.&hyperize.map({ FIRST say "first" unless $++; 42 });
```
**Caveat**: if a `last` statement is executed, it will ensure that no further values will be delivered. However, this may not stop other threads immediately. So any other phasers, such as `ENTER`, `LEAVE` and `NEXT` may still get executed, even though the values that were produced, will not be delivered.
**Caveat**: to catch any execution of `last`, the `ParaSeq` module exports its own `last` subroutine. This means that any mapper code will either have to live within the scope in which the `use ParaSeq` command is executed, to ensure proper `last` handling in a hypered `.map`.
## max
An optimized version of the [`.max`](https://docs.raku.org/type/Any#routine_max) method with named arguments, has been implemented.
## maxpairs
An optimized version of the [`.maxpairs`](https://docs.raku.org/type/Any#routine_maxpairs) method has been implemented.
## min
An optimized version of the [`.min`](https://docs.raku.org/type/Any#routine_min) method with named arguments, has been implemented.
## minpairs
An optimized version of the [`.minpairs`](https://docs.raku.org/type/Any#routine_minpairs) method has been implemented.
## nodemap
An optimized version of the [`.nodemap`](https://docs.raku.org/type/Any#method_nodemap) method has been implemented.
**Caveat**: to catch any execution of `last`, the `ParaSeq` module exports its own `last` subroutine. This means that any mapper code will either have to live within the scope in which the `use ParaSeq` command is executed, to ensure proper `last` handling in a hypered `.nodemap`.
## pairs
An optimized version of the [`.pairs`](https://docs.raku.org/type/List#routine_pairs) method has been implemented.
## pairup
The nature of the [`pairup`](https://docs.raku.org/type/Any#method_pairup) method basically makes it impossible to hyper. Therefore, **no** specific hypering logic has been added for this method.
## permutations
The nature of the [`.permutations`](https://docs.raku.org/type/List#routine_permutations) method basically makes it impossible to hyper. Therefore, **no** specific hypering logic has been added for this method.
## pick
The nature of the [`.pick`](https://docs.raku.org/type/List#routine_pick) method basically makes it impossible to hyper. Therefore, **no** specific hypering logic has been added for this method.
## produce
The nature of the [`.produce`](https://docs.raku.org/type/Any#routine_produce) method basically makes it impossible to hyper. Therefore, **no** specific hypering logic has been added for this method.
## repeated
The nature of the [`.repeated`](https://docs.raku.org/type/Any#method_repeated) method basically makes it impossible to hyper. Therefore, **no** specific hypering logic has been added for this method.
## reverse
The nature of the [`.reverse`](https://docs.raku.org/type/List#routine_reverse) method basically makes it impossible to hyper. Therefore, **no** specific hypering logic has been added for this method.
## roll
The nature of the [`.roll`](https://docs.raku.org/type/List#routine_roll) method basically makes it impossible to hyper. Therefore, **no** specific hypering logic has been added for this method.
## rotate
The nature of the [`.rotate`](https://docs.raku.org/type/List#routine_rotate) method basically makes it impossible to hyper. Therefore, **no** specific hypering logic has been added for this method.
## rotor
An optimized version of the [`.rotor`](https://docs.raku.org/type/List#routine_rotor) method has been implemented for the single argument non-`Pair` case. All other cases are basically too complicated to hyper, and therefore have no specific hypering logic.
## skip
The simple cases of `.skip()` and `.skip(N)` are handled by skipping that amount on the result iterator and returning the invocant.
The nature of the other types of arguments on the [`.skip`](https://docs.raku.org/type/Seq#method_skip) method basically makes it impossible to hyper. Therefore, **no** specific hypering logic has been added for these cases.
## slice
The nature of the [`.slice`](https://docs.raku.org/type/Seq#multi_method_slice) method basically makes it impossible to hyper. Therefore, **no** specific hypering logic has been added for this method.
## snip
The nature of the [`.snip`](https://docs.raku.org/type/Any#routine_snip) method basically makes it impossible to hyper. Therefore, **no** specific hypering logic has been added for this method.
## snitch
Since it doesn't make much sense for the [`.snitch`](https://docs.raku.org/type/Any#routine_snitch) method to be called on the `ParaSeq` object as a whole, calling the `.snitch` method instead activates snitcher logic on the `ParaSeq` object itself. If set, the snitcher code will be called for each input buffer before being scheduled (in a threadsafe manner). The snitcher code will receive this buffer as a `List`.
## sort
The nature of the [`.sort`](https://docs.raku.org/type/List#routine_sort) method basically makes it impossible to hyper. Therefore, **no** specific hypering logic has been added for this method.
## squish
An optimized version of the [`.squish`](https://docs.raku.org/type/Any#method_squish) method has been implemented if either a `:as` named argument has been specified, or a `:with` named argument with something other than the `===` operator has been specified. The default case of the `.squish` method is already highly optimized so it doesn't make any sense to add any hypering logic for that case.
## tail
The nature of the [`.tail`](https://docs.raku.org/type/List#method_tail) method basically makes it impossible to hyper. Therefore, **no** specific hypering logic has been added for this method.
## toggle
The nature of the [`.toggle`](https://docs.raku.org/type/Any#method_toggle) method basically makes it impossible to hyper. Therefore, **no** specific hypering logic has been added for this method.
## unique
An optimized version of the [`.unique`](https://docs.raku.org/type/Any#method_unique) method has been implemented.
**Caveat**: using the `:with` option with an operator that checks for **inequality**, may produce erroneous results.
## values
The [`.values`](https://docs.raku.org/type/List#routine_values) is basically a no-op, so it returns the invocant for simplicity.
# COERCERS
The following coercers have been optimized as much as possible with the use of `&hyperize`. Note that these methods are optimized for speed, rather than memory usage. Should you want to optimize for memory usage, then put in a `.Seq` coercer first. Or remove `.&hyperize` completely. So:
```
my $speed = (^1_000_000).&hyperize.Set; # optimized for speed
my $memory = (^1_000_000).&hyperize.Seq.Set; # optimized for memory
my $none = (^1_000_000).Seq.Set; # no parallelization
```
In alphabetical order:
## Array
The [`Array`](https://docs.raku.org/type/Array) coercer has been implemented: it removes all hypering information from its invocant.
## Bag
Putting together the [`Bag`](https://docs.raku.org/type/Bag) of each batch in a correct manner, would be complicated and potentially CPU intensive. Therefore, **no** specific hypering logic has been added for this coercer at this point.
## BagHash
Putting together the [`BagHash`](https://docs.raku.org/type/BagHash) of each batch in a correct manner, would be complicated and potentially CPU intensive. Therefore, **no** specific hypering logic has been added for this coercer at this point.
## Bool
An optimized version of the [`Bool`](https://docs.raku.org/type/Bool) coercer has been implemented.
## eager
The [`.eager`](https://docs.raku.org/type/List#routine_eager) method is functionally the same as the `.List`, and has been implemented as such.
## Hash
Putting together the [`Hash`](https://docs.raku.org/type/Hash) of each batch in a correct manner, would be complicated and potentially CPU intensive. Therefore, **no** specific hypering logic has been added for this coercer at this point.
## Int
An optimized version of the [`Int`](https://docs.raku.org/type/Int) coercer has been implemented.
## IterationBuffer
The [`IterationBuffer`](https://docs.raku.org/type/IterationBuffer) coercer collects the result of the invocant in an `IterationBuffer` and returns that.
## list
The [`list`](https://docs.raku.org/routine/list) coercer is implemented: it creates a `List` object with the object's iterator as its "todo" (so no elements are reified until they are actually demanded). And thus removes all hypering information.
## List
The [`List`](https://docs.raku.org/type/List) coercer has been implemented: it creates a fully reified `List` and thus removes all hypering information.
## Map
Putting together the [`Map`](https://docs.raku.org/type/Map) of each batch in a correct manner, would be complicated and potentially CPU intensive. Therefore, **no** specific hypering logic has been added for this coercer at this point.
## Mix
Putting together the [`Mix`](https://docs.raku.org/type/Mix) of each batch in a correct manner, would be complicated and potentially CPU intensive. Therefore, **no** specific hypering logic has been added for this coercer at this point.
## MixHash
Putting together the [`MixHash`](https://docs.raku.org/type/MixHash) of each batch in a correct manner, would be complicated and potentially CPU intensive. Therefore, **no** specific hypering logic has been added for this coercer at this point.
## Numeric
An optimized version of the [`Int`](https://docs.raku.org/type/Numeric) coercer has been implemented.
## Seq
The [`Seq`](https://docs.raku.org/type/Seq) coercer has been implemented: it removes all hypering information from its invocant.
## serial
The [`.serial`](https://docs.raku.org/type/HyperSeq#method_serial) method is functionally the same as the `.Seq`, and has been implemented as such.
## Set
Putting together the [`Set`](https://docs.raku.org/type/Set) of each batch in a correct manner, would be complicated and potentially CPU intensive. Therefore, **no** specific hypering logic has been added for this coercer at this point.
## SetHash
Putting together the [`SetHash`](https://docs.raku.org/type/SetHash) of each batch in a correct manner, would be complicated and potentially CPU intensive. Therefore, **no** specific hypering logic has been added for this coercer at this point.
## Slip
The [`Slip`](https://docs.raku.org/type/Slip) coercer has been implemented: it removes all hypering information from its invocant.
## Str
An optimized version of the [`Str`](https://docs.raku.org/type/Str) coercer has been implemented.
# PUBLIC CLASSES
## ParaSeq
The class of which an instance is returned by `hyperize` and `racify` if the requirements for parallelizing have been met.
Can be used in any situation where a `Seq` could also be used. The following additional methods can also be called for introspection and debugging. In alphabetical order:
### auto
Bool. Returns whether batch sizes will be automatically optimized to provide the best throughput.
### batch-sizes
Range. The smallest and largest batch size as a `Range`.
### catch
Bool. Returns whether exceptions in parallel worker threads will be caught.
### default-batch
```
say ParaSeq.default-batch; # 16
ParaSeq.default-batch = 1024;
say ParaSeq.default-batch; # 1024
```
Int. The default initial batch size: currently `16`. Can also be used to change the default batch size by assigning to it.
### default-degree
```
say ParaSeq.default-degree; # 7
ParaSeq.default-degree = 3;
say ParaSeq.defaultdegreebatch; # 3
```
Int. The default maximum number of worker threads to be used. Currently set to the number of available CPUs minus one. Can also be used to change the default maximum number of worker threads by assigning to it.
### exceptions
Bag. Returns a `Bag` of exceptions that were caught in parallel processing **so far**, keyed to the `.gist` of the execution error (and the value being the number of times they occurred).
By default, any caught exceptions will be printed on STDERR at the end of the process. Calling this method effectively clears the caught exceptions, so that it can also be used to inhibit showing any execution errors.
### hyper
Change hypering settings on invocant and returns invocant. Takes the same arguments as `&hyperize`. Additionally takes a `:racing` named argument, to indicate `racing` or `hypering` semantics.
### is-lazy
Bool. Returns whether the `ParaSeq` iterator should be considered lazy or not. It will be considered lazy if the source iterator is lazy.
### processed
Int. The number of items processed, as obtained from the `stats`.
### produced
Int. The number of items produced, as obtained from the `stats`.
### racing
Bool. Returns `True` if racing (aka, parallelizing without taking care of the order in which values will be delivered). Else `False`.
### stats
A `List` of `ParaStats` objects that were produced, in the order that they were produced. Note that due to the asynchronous nature of stats production and processing, this may be incomplete at any given time.
### threads
Returns a `List` of the IDs of the CPU threads that have been used to produce the result.
## ParaStats
The `ParaStats` class is created for each batch that has been processed. It provides the following methods (in alphabetical order):
### nsecs
Int. The number of nano-seconds that it took to process all values in the associated batch.
### ordinal
Int. The ordinal number of the associated batch (starting at 0).
### processed
Int. The number of values processed in the associated batch (aka the batch size of that batch).
### produced
Int. The number of values that were produced in the associated batch. This can be `0`, or a higher value than `processed` when `.map` was called with a `Callable` that produced `Slip` values.
### smoothed-nsecs
Int. The number of nano-seconds that it took to process all values in the associated batch, corrected for any Garbage Collection cycles.
### threadid
Int. The numerical ID of low-level thread that processed the associated batch (aka its `$*THREAD.id`).
# IMPROVEMENTS
## Automatic batch size adaptation
One of the main issues with the current implemementation of `.hyper` and `.race` in the Rakudo core is that the batch size is fixed. Worse, there is no way to dynamically adapt the batch size depending on the load.
Batch sizes that are too big, have a tendency to not use all of the CPUs (because they have a tendency to eat all of the source items too soon, thus removing the chance to start up more threads).
Batch sizes that are too small, have a tendency to have their resource usage drowned out by the overhead of batching and dispatching to threads.
This implementation automatically adapts batch sizes from the originally (implicitely) specified batch size for better throughput and resource usage. If this feature is not desired, the `:!auto` argument can be used to switch automatic batch size adjustment off.
## Unnecessary parallelization
If the `degree` specified is **1**, then there is no point in batching or parallelization. In that case, this implementation will take itself completely out of the flow.
Alternately, if the initial batch size is large enough to exhaust the source, it is clearly too large. Which is interpreted as not making any sense at parallelization either. So it won't.
Note that the default initial batch size is **16**, rather than **64** in the current implementation of `.hyper` and `.race`, making the chance smaller that parallelization is abandoned too soon.
## Infectiousness
The `.serial` method or `.Seq` coercer can be typically be used to "unhyper" a hypered sequence. However many other interface methods do the same in the current implementation of `.hyper` and `.race`, thereby giving the impression that the flow is still parallelized. When in fact they aren't anymore.
Also, hyperized sequences in the current implementation are considered to be non-lazy, even if the source **is** lazy.
This implementation aims to make all interface methods pass on the hypered nature and laziness of the sequence.
## Loop control statements
Some loop control statements may affect the final result. Specifically the `last` statement does. In the current implementation of `.hyper` and `.race`, this will only affect the batch in which it occurs.
This implementation aims to make `last` stop any processing of current and not create anymore batches.
## Support more interface methods
Currently only the `.map` and `.grep` methods are supported by the current implementation of `.hyper` and `.race` (and not even completely). Complete support for `.map` and `.grep` are provided, and other methods (such as `.first`) will also be supported.
## Use of phasers
When an interface method takes a `Callable`, then that `Callable` can contain phasers that may need to be called (or not called) depending on the situation. The current implementation of `.hyper` and `.race` do not allow phasers at all.
This implementation aims to support phasers in a sensible manner:
### ENTER
Called before each iteration.
### FIRST
Called on the first iteration in the first batch.
### NEXT
Called at the end of each iteration.
### LAST
Called on the last iteration in the last batch. Note that this can be short-circuited with a `last` control statement.
### LEAVE
Called after each iteration.
# THEORY OF OPERATION
A description of the program logic when you call `.&hyperize` on an object.
## Step 1: is degree > 1
If the degree is 1, then there's nothing to parallelize. The `&hyperize` sub will return its first argument. Since `.&hyperize` will most likely mostly be called as a method, the first argument will be described as the "invocant".
## Step 2: fetch the initial batch
Obtain an iterator from the invocant and read as many items into an `IterationBuffer` as the initial batch size indicates. If this exhausted the source iterator, then return a `Seq` on that `IterationBuffer`. This also effectively inhibits any parallelization.
## Step 3: create a ParaSeq
If step 1 and 2 didn't result in a premature return, then a `ParaSeq` object is created and returned. Apart from the initial `IterationBuffer` and source iterator, it also contains:
* the initial batch size
* the degree (max number of worker threads)
* the "auto" flag
* the $\*SCHEDULER value
## Step 4: an interface method is called
Each interface method decides whether they can support an optimized hypered operation. If does **not** support hypered operation, a special `BufferIterator` is created. This iterator takes the buffer and the source iterator from step 2, that will first deliver the values from the buffer, and then the values from the source iterator (until that is exhausted).
The following step then depends on whether the method is an endpoint (such as `max`) or a coercer (such as `Str`). If it is, then the `BufferIterator` will be wrapped in a standard `Seq` object and the core equivalent of that method will be called on it and its result returned.
If it is an other interface method, then a clone of the original invocant is created with the `BufferIterator` object as its source iterator. And that is then returned.
If the method **can** be parallized, then we continue.
## Step 5: check granularity of initial batch
Some methods (such as `map` and `grep`) **may** require more than 1 value per iteration (the granularity). Batches need to have a size with the correct granularity, otherwise processing a batch may fail at the last iteration for lack of positional arguments.
So read additional values from the source iterator until the granularity is correct.
## Step 6: keep producers in check
One of the issues with hypering, is that multiple threads can easily produce so many values that the deliverer can be overwhelmed in the worst case. Or at least, it could be wasteful in resources because it would produce way more values than would actually need to be delivered. For example:
```
say (^Inf).&hyperize.map(*.is-prime)[999999]; # the millionth prime number
```
One would not want the parallelization to calculate 1.2 million prime numbers while only needing 1 million. Yet, this will happen quite easily if there is not enough ["back pressure"](https://medium.com/@jayphelps/backpressure-explained-the-flow-of-data-through-software-2350b3e77ce7).
So the thread delivering values, needs to be able to tell the batcher when it is ok to schedule another batch for processing. This is done through a `ParaQueue` object (a low-level blocking concurrent queue to which the delivering thread will push whenever it has delivered the results of a result batch. Since "back pressure queue" is a bit of a mouthful, this is being referred to as the "pressure queue".
The deliverer is also responsible for telling the batcher what it thinks the best size for the next batch is. See Step 6.
To get things started, a pressure queue is set up with various batch sizes (one for each degree) so that maximally that many threads can be started. By using variable sizes, the delivery iterator can more quickly decide what the optimum size is for the given workload because the different batch sizes produce different average time needed per processed value. Which is used to calculate the optimum batch size.
## Step 7: set up the result queue
The result queue is where all of the worker threads post the result of processing their batch. The result queue is a `ParaQueue` of `ParaQueue`s. Whenever the batcher is told that it may queue up the next batch, the batcher also pushes a new `ParaQueue` object to the result queue **and** passes that `ParaQueue` object to the worker thread. So that when the worker thread is done processing, it can push its result to **that** `ParaQueue`.
The `ParaQueue` that is pushed to the result queue by the batcher ensures that the order in which batches of work are handed out, will also be the order in which the results will be delivered. The fact that the result of processing is pushed to this `ParaQueue` itself, makes the deliverer block until the worker thread has pushed its result (even if other threads may have been ready earlier).
## Step 8: set up the waiting queue
To communicate back performance statistics from a worker thread finishing their work, another `ParaQueue` is created. Its sole purpose is to collect all `ParaStats` objects that each worker thread has completed **as soon as they are done**. It basically also represents the number of result batches that are waiting to be delivered: hence the name "waiting queue".
This queue is inspected by the delivery thread whenever it has completed delivery of a batch. It's possible that this queue is empty. It can also contain the statistics of more than one worker thread.
## Step 9: start the batcher thread
The batcher thread keeps running until the source iterator is exhausted. When it is exhausted, it pushes an `IterationEnd` to the result queue, indicating that no more batches will be coming. It's the only time a non-`ParaQueue` object is pushed to the result queue.
The batcher is basically a loop that blocks on the messages from the deliverer. Whenever a message is received (with the proposed batch size, calculated from any available performance statistics), it adjusts for |
## dist_zef-lizmat-ParaSeq.md
## Chunk 2 of 2
correct granularity (as the deliverer is unaware of any granularity restrictions). The batcher then fetches that many values from the source iterator and schedules another job for a worker thread with the values obtained (if any).
## Step 10: start delivering
At this point a `ParaIterator` object is created and installed as the (result) `.iterator` of the invocant. The paralellizing logic in the hypered variant of the method is started, which then in turn starts feeding the `ParaIterator`.
It is then up to the code that iterators over the (result) iterator to consume the values delivered. If no values are being delivered, production of values will halt after all inital "degree" batches have been produced.
When the deliverer is done with a result batch, it removes all available statistics information and adds these to the `stats` of the `ParaSeq` object. It also uses this information to calculate an optimum batch size for any other batches to be processed (unless this is inhibited by the `:!auto` named argument to `.&hyperize`).
The algorithm for batch size calculation is pretty simple at the moment. To allow for optimum responsiveness of the program, as well as any other processes running on the computer, a time slice of 1\_000\_000 nanoseconds (aka 1 millisecond) has been chosen.
If a batch took almost exactly that amount of time to produce values, then the size of that batch is assumed to be the optimum size. If the batch took longer, then the batch size should be reduced. If the batch took less than that to complete, then the batch size should be increased.
## Decision tree
```
source
\- hyperize
|- invocant (degree == 1)
|- Seq (source exhausted with initial batch)
|- ParaSeq
\- method call
|- endpoint
|- coercer
|- hypering
```
## Hypering control flow
```
/---------------------------------------------------------\
| | |
| ⬇ |
| -------------- ------------ |
| | statistics | /-----⮕ | producer | ⮕ -|
| -------------- / ------------ |
⬇ ⬇ / |
----------- ------------ ----------- ------------ |
| results | ⮕ | deliverer | ⮕ | batcher | ⮕ | producer | ⮕ -|
----------- ------------ ----------- ------------ |
| \ |
| \ ------------ |
| \-----⮕ | producer | ⮕ -/
⬇ ------------
values
consumed by program
```
# AUTHOR
Elizabeth Mattijsen [liz@raku.rocks](mailto:liz@raku.rocks)
Source can be located at: <https://github.com/lizmat/ParaSeq> . Comments and Pull Requests are welcome.
If you like this module, or what I’m doing more generally, committing to a [small sponsorship](https://github.com/sponsors/lizmat/) would mean a great deal to me!
# COPYRIGHT AND LICENSE
Copyright 2024 Elizabeth Mattijsen
This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.
|
## dist_zef-dwarring-PDF-ISO_32000.md
## Chunk 1 of 10
[[Raku PDF Project]](https://pdf-raku.github.io)
/ [PDF::ISO\_32000](https://pdf-raku.github.io/PDF-ISO_32000-raku)
# PDF-ISO\_32000-raku
The PDF 32000-1:2008 1.7 Specification contains around 380 tables, of which about 280 can be considered data or object definitions.
This module has been used to extract and generate the roles and classes from the PDF
specification for use by PDF::Class.
PDF::Class (at last count) implements roles and classes for about 100 of these objects, most of which
have been derived and/or checked against the roles generated by this module.
This module contains:
* [JSON tables](https://github.com/pdf-raku/PDF-ISO_32000-raku/blob/master/resources/) extracted from the above
* [generated interface roles](https://github.com/pdf-raku/PDF-ISO_32000-raku/blob/master/gen/lib/ISO_32000) for building and validating PDF objects
* scripts and Makefiles for regenerating the XML tables and roles
## Tables
Data is available for all of the tables in the PDF-32000 1.7 specification:
```
use PDF::ISO_32000;
# Load data about the Document Information dictionary
my %info = PDF::ISO_32000.table: "Table_317-Entries_in_the_document_information_dictionary";
# -OR- by table number
%info = PDF::ISO_32000.[317];
say %info<caption>; # Table 317 – Entries in the document information dictionary
say %info<head>.join(" | "); # Key | Type | Value
say %info<rows>[0].join(" | "); # Title | text string | (Optional; PDF 1.1) The document’s title.
```
The `table-index` method returns a list that maps table numbers to table names:
```
say PDF::ISO_32000.table-index[317] # Table 317 - Info_entries
```
The `appendix` method returns a hash index into the Appendix:
```
my $stream-ops = PDF::ISO_32000.appendix<A.1>;
say $stream-ops, # PDF_content_stream_operators
say PDF::ISO_32000.table($stream-ops)<caption>; # Table A.1 – PDF content stream operators
```
## Roles
Roles are available for tables named `*_entries`, or `*_attributes`.
```
% p6doc ISO_320000:Table_317-Entries_in_the_document_information_dictionary
% p6doc ISO_320000:Table_28-Entries_in_the_catalog_dictionary
```
The roles also contain [method stubs](https://docs.raku.org/language/objects#Stubs) for the entries that need to be implemented for the role. For example:
```
% cat << EOF > lib/Catalog.rakumod
use ISO_32000::Table_28-Entries_in_the_catalog_dictionary;
unit class Catalog does ISO_32000::Table_28-Entries_in_the_catalog_dictionary;
EOF
% raku -I . -M Catalog
===SORRY!=== Error while compiling lib/Catalog.rakumod (Catalog)
Method 'SpiderInfo' must be implemented by Catalog because it is required by roles: ISO_32000::Table_28-Entries_in_the_catalog_dictionary.
at lib/Catalog.rakumod (Catalog):1
```
### Building this module
Note that the `META6.json` and `README.md` are generated. Any edits
the these files should be made to the sources `src/META6.in` and `src/README.in`, before building.
To rebuild the roles, resources, README.md and META6.json:
```
$ make clean
$ make
$ make test
```
Or to fully rebuild the module type `$ make realclean`. This will refetch specification and rebuild the the XML extract `gen/PDF-ISO_32000.xml`. This will take some time. At least `2Gb` of available memory is recommended. The `wget` utility
and network access are also required.
* This module has been developed on Linux using `GNU Make`
### Maintaining and releasing this module
This module needs to have its Change-log edited and version incremented manually. It is then built via `make`. `make dist` is used to build a tar-ball, which
is then released via `fez`. For example:
```
$ vim Changes
$ vim lib/PDF/ISO_32000.rakumod # update version number
$ make
$ make test
$ make dist
$ fez upload --file=PDF-ISO_32000-9.9.99.tar.gz # upload this version
```
## ISO 3200 Roles
The following interface roles have been mined from the ISO-32000 specification
### Roles and Entries
| ISO\_32000 Reference | Entries |
| --- | --- |
| [Table F.1 – Entries in the linearization parameter dictionary](lib/ISO_32000/Table_F1-Entries_in_the_linearization_parameter_dictionary.rakumod) | /Linearized /L /H /O /E /N /T /P |
| [Table 5 – Entries common to all stream dictionaries](lib/ISO_32000/Table_5-Entries_common_to_all_stream_dictionaries.rakumod) | /Length /Filter /DecodeParms /F /FFilter /FDecodeParms /DL |
| [Table 8 – Optional parameters for LZWDecode and FlateDecode filters](lib/ISO_32000/Table_8-Optional_parameters_for_LZWDecode_and_FlateDecode_filters.rakumod) | /Predictor /Colors /BitsPerComponent /Columns /EarlyChange |
| [Table 11 – Optional parameters for the CCITTFaxDecode filter](lib/ISO_32000/Table_11-Optional_parameters_for_the_CCITTFaxDecode_filter.rakumod) | /K /EndOfLine /EncodedByteAlign /Columns /Rows /EndOfBlock /BlackIs1 /DamagedRowsBeforeError |
| [Table 12 – Optional parameter for the JBIG2Decode filter](lib/ISO_32000/Table_12-Optional_parameter_for_the_JBIG2Decode_filter.rakumod) | /JBIG2Globals |
| [Table 13 – Optional parameter for the DCTDecode filter](lib/ISO_32000/Table_13-Optional_parameter_for_the_DCTDecode_filter.rakumod) | /ColorTransform |
| [Table 14 – Optional parameters for Crypt filters](lib/ISO_32000/Table_14-Optional_parameters_for_Crypt_filters.rakumod) | /Type /Name |
| [Table 15 – Entries in the file trailer dictionary](lib/ISO_32000/Table_15-Entries_in_the_file_trailer_dictionary.rakumod) | /Size /Prev /Root /Encrypt /Info /ID |
| [Table 16 – Additional entries specific to an object stream dictionary](lib/ISO_32000/Table_16-Additional_entries_specific_to_an_object_stream_dictionary.rakumod) | /Type /N /First /Extends |
| [Table 17 – Additional entries specific to a cross-reference stream dictionary](lib/ISO_32000/Table_17-Additional_entries_specific_to_a_cross-reference_stream_dictionary.rakumod) | /Type /Size /Index /Prev /W |
| [Table 19 – Additional entries in a hybrid-reference file’s trailer dictionary](lib/ISO_32000/Table_19-Additional_entries_in_a_hybrid-reference_files_trailer_dictionary.rakumod) | /XRefStm |
| [Table 20 – Entries common to all encryption dictionaries](lib/ISO_32000/Table_20-Entries_common_to_all_encryption_dictionaries.rakumod) | /Filter /SubFilter /V /Length /CF /StmF /StrF /EFF |
| [Table 21 – Additional encryption dictionary entries for the standard security handler](lib/ISO_32000/Table_21-Additional_encryption_dictionary_entries_for_the_standard_security_handler.rakumod) | /R /O /U /P /EncryptMetadata |
| [Table 23 – Additional encryption dictionary entries for public-key security handlers](lib/ISO_32000/Table_23-Additional_encryption_dictionary_entries_for_public-key_security_handlers.rakumod) | /Recipients /P |
| [Table 25 – Entries common to all crypt filter dictionaries](lib/ISO_32000/Table_25-Entries_common_to_all_crypt_filter_dictionaries.rakumod) | /Type /CFM /AuthEvent /Length |
| [Table 27 – Additional crypt filter dictionary entries for public-key security handlers](lib/ISO_32000/Table_27-Additional_crypt_filter_dictionary_entries_for_public-key_security_handlers.rakumod) | /Recipients /EncryptMetadata |
| [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) | /Type /Version /Extensions /Pages /PageLabels /Names /Dests /ViewerPreferences /PageLayout /PageMode /Outlines /Threads /OpenAction /AA /URI /AcroForm /Metadata /StructTreeRoot /MarkInfo /Lang /SpiderInfo /OutputIntents /PieceInfo /OCProperties /Perms /Legal /Requirements /Collection /NeedsRendering |
| [Table 29 – Required entries in a page tree node](lib/ISO_32000/Table_29-Required_entries_in_a_page_tree_node.rakumod) | /Type /Parent /Kids /Count |
| [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) | /Type /Parent /LastModified /Resources /MediaBox /CropBox /BleedBox /TrimBox /ArtBox /BoxColorInfo /Contents /Rotate /Group /Thumb /B /Dur /Trans /Annots /AA /Metadata /PieceInfo /StructParents /ID /PZ /SeparationInfo /Tabs /TemplateInstantiated /PresSteps /UserUnit /VP |
| [Table 31 – Entries in the name dictionary](lib/ISO_32000/Table_31-Entries_in_the_name_dictionary.rakumod) | /Dests /AP /JavaScript /Pages /Templates /IDS /URLS /EmbeddedFiles /AlternatePresentations /Renditions |
| [Table 33 – Entries in a resource dictionary](lib/ISO_32000/Table_33-Entries_in_a_resource_dictionary.rakumod) | /ExtGState /ColorSpace /Pattern /Shading /XObject /Font /ProcSet /Properties |
| [Table 36 – Entries in a name tree node dictionary](lib/ISO_32000/Table_36-Entries_in_a_name_tree_node_dictionary.rakumod) | /Kids /Names /Limits |
| [Table 37 – Entries in a number tree node dictionary](lib/ISO_32000/Table_37-Entries_in_a_number_tree_node_dictionary.rakumod) | /Kids /Nums /Limits |
| [Table 38 – Entries common to all function dictionaries](lib/ISO_32000/Table_38-Entries_common_to_all_function_dictionaries.rakumod) | /FunctionType /Domain /Range |
| [Table 39 – Additional entries specific to a type 0 function dictionary](lib/ISO_32000/Table_39-Additional_entries_specific_to_a_type_0_function_dictionary.rakumod) | /Size /BitsPerSample /Order /Encode /Decode |
| [Table 40 – Additional entries specific to a type 2 function dictionary](lib/ISO_32000/Table_40-Additional_entries_specific_to_a_type_2_function_dictionary.rakumod) | /C0 /C1 /N |
| [Table 41 – Additional entries specific to a type 3 function dictionary](lib/ISO_32000/Table_41-Additional_entries_specific_to_a_type_3_function_dictionary.rakumod) | /Functions /Bounds /Encode |
| [Table 44 – Entries in a file specification dictionary](lib/ISO_32000/Table_44-Entries_in_a_file_specification_dictionary.rakumod) | /Type /FS /F /UF /DOS /Mac /Unix /ID /V /EF /RF /Desc /CI |
| [Table 45 – Additional entries in an embedded file stream dictionary](lib/ISO_32000/Table_45-Additional_entries_in_an_embedded_file_stream_dictionary.rakumod) | /Type /Subtype /Params |
| [Table 46 – Entries in an embedded file parameter dictionary](lib/ISO_32000/Table_46-Entries_in_an_embedded_file_parameter_dictionary.rakumod) | /Size /CreationDate /ModDate /Mac /CheckSum |
| [Table 47 – Entries in a Mac OS file information dictionary](lib/ISO_32000/Table_47-Entries_in_a_Mac_OS_file_information_dictionary.rakumod) | /Subtype /Creator /ResFork |
| [Table 48 – Entries in a collection item dictionary](lib/ISO_32000/Table_48-Entries_in_a_collection_item_dictionary.rakumod) | /Type |
| [Table 49 – Entries in a collection subitem dictionary](lib/ISO_32000/Table_49-Entries_in_a_collection_subitem_dictionary.rakumod) | /Type /D /P |
| [Table 50 – Entries in a developer extensions dictionary](lib/ISO_32000/Table_50-Entries_in_a_developer_extensions_dictionary.rakumod) | /Type /BaseVersion /ExtensionLevel |
| [Table 52 – Device-Independent Graphics State Parameters](lib/ISO_32000/Table_52-Device-Independent_Graphics_State_Parameters.rakumod) | /CTM /clippingPath /colorSpace /color /textState /lineWidth /lineCap /lineJoin /miterLimit /dashPattern /renderingIntent /strokeAdjustment /blendMode /softMask /alphaConstant /alphaSource |
| [Table 53 – Device-Dependent Graphics State Parameters](lib/ISO_32000/Table_53-Device-Dependent_Graphics_State_Parameters.rakumod) | /overprint /overprintMode /blackGeneration /undercolorRemoval /transfer /halftone /flatness /smoothness |
| [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) | /Type /LW /LC /LJ /ML /D /RI /OP /op /OPM /Font /BG /BG2 /UCR /UCR2 /TR /TR2 /HT /FL /SM /SA /BM /SMask /CA /ca /AIS /TK |
| [Table 63 – Entries in a CalGray Colour Space Dictionary](lib/ISO_32000/Table_63-Entries_in_a_CalGray_Colour_Space_Dictionary.rakumod) | /WhitePoint /BlackPoint /Gamma |
| [Table 64 – Entries in a CalRGB Colour Space Dictionary](lib/ISO_32000/Table_64-Entries_in_a_CalRGB_Colour_Space_Dictionary.rakumod) | /WhitePoint /BlackPoint /Gamma /Matrix |
| [Table 65 – Entries in a Lab Colour Space Dictionary](lib/ISO_32000/Table_65-Entries_in_a_Lab_Colour_Space_Dictionary.rakumod) | /WhitePoint /BlackPoint /Range |
| [Table 66 – Additional Entries Specific to an ICC Profile Stream Dictionary](lib/ISO_32000/Table_66-Additional_Entries_Specific_to_an_ICC_Profile_Stream_Dictionary.rakumod) | /N /Alternate /Range /Metadata |
| [Table 71 – Entries in a DeviceN Colour Space Attributes Dictionary](lib/ISO_32000/Table_71-Entries_in_a_DeviceN_Colour_Space_Attributes_Dictionary.rakumod) | /Subtype /Colorants /Process /MixingHints |
| [Table 72 – Entries in a DeviceN Process Dictionary](lib/ISO_32000/Table_72-Entries_in_a_DeviceN_Process_Dictionary.rakumod) | /ColorSpace /Components |
| [Table 73 – Entries in a DeviceN Mixing Hints Dictionary](lib/ISO_32000/Table_73-Entries_in_a_DeviceN_Mixing_Hints_Dictionary.rakumod) | /Solidities /PrintingOrder /DotGain |
| [Table 75 – Additional Entries Specific to a Type 1 Pattern Dictionary](lib/ISO_32000/Table_75-Additional_Entries_Specific_to_a_Type_1_Pattern_Dictionary.rakumod) | /Type /PatternType /PaintType /TilingType /BBox /XStep /YStep /Resources /Matrix |
| [Table 76 – Entries in a Type 2 Pattern Dictionary](lib/ISO_32000/Table_76-Entries_in_a_Type_2_Pattern_Dictionary.rakumod) | /Type /PatternType /Shading /Matrix /ExtGState |
| [Table 78 – Entries Common to All Shading Dictionaries](lib/ISO_32000/Table_78-Entries_Common_to_All_Shading_Dictionaries.rakumod) | /ShadingType /ColorSpace /Background /BBox /AntiAlias |
| [Table 79 – Additional Entries Specific to a Type 1 Shading Dictionary](lib/ISO_32000/Table_79-Additional_Entries_Specific_to_a_Type_1_Shading_Dictionary.rakumod) | /Domain /Matrix /Function |
| [Table 80 – Additional Entries Specific to a Type 2 Shading Dictionary](lib/ISO_32000/Table_80-Additional_Entries_Specific_to_a_Type_2_Shading_Dictionary.rakumod) | /Coords /Domain /Function /Extend |
| [Table 81 – Additional Entries Specific to a Type 3 Shading Dictionary](lib/ISO_32000/Table_81-Additional_Entries_Specific_to_a_Type_3_Shading_Dictionary.rakumod) | /Coords /Domain /Function /Extend |
| [Table 82 – Additional Entries Specific to a Type 4 Shading Dictionary](lib/ISO_32000/Table_82-Additional_Entries_Specific_to_a_Type_4_Shading_Dictionary.rakumod) | /BitsPerCoordinate /BitsPerComponent /BitsPerFlag /Decode /Function |
| [Table 83 – Additional Entries Specific to a Type 5 Shading Dictionary](lib/ISO_32000/Table_83-Additional_Entries_Specific_to_a_Type_5_Shading_Dictionary.rakumod) | /BitsPerCoordinate /BitsPerComponent /VerticesPerRow /Decode /Function |
| [Table 84 – Additional Entries Specific to a Type 6 Shading Dictionary](lib/ISO_32000/Table_84-Additional_Entries_Specific_to_a_Type_6_Shading_Dictionary.rakumod) | /BitsPerCoordinate /BitsPerComponent /BitsPerFlag /Decode /Function |
| [Table 88 – Additional Entries Specific to a PostScript XObject Dictionary](lib/ISO_32000/Table_88-Additional_Entries_Specific_to_a_PostScript_XObject_Dictionary.rakumod) | /Type /Subtype /Level1 |
| [Table 89 – Additional Entries Specific to an Image Dictionary](lib/ISO_32000/Table_89-Additional_Entries_Specific_to_an_Image_Dictionary.rakumod) | /Type /Subtype /Width /Height /ColorSpace /BitsPerComponent /Intent /ImageMask /Mask /Decode /Interpolate /Alternates /SMask /SMaskInData /Name /StructParent /ID /OPI /Metadata /OC |
| [Table 91 – Entries in an Alternate Image Dictionary](lib/ISO_32000/Table_91-Entries_in_an_Alternate_Image_Dictionary.rakumod) | /Image /DefaultForPrinting /OC |
| [Table 95 – Additional Entries Specific to a Type 1 Form Dictionary](lib/ISO_32000/Table_95-Additional_Entries_Specific_to_a_Type_1_Form_Dictionary.rakumod) | /Type /Subtype /FormType /BBox /Matrix /Resources /Group /Ref /Metadata /PieceInfo /LastModified /StructParent /StructParents /OPI /OC /Name |
| [Table 96 – Entries Common to all Group Attributes Dictionaries](lib/ISO_32000/Table_96-Entries_Common_to_all_Group_Attributes_Dictionaries.rakumod) | /Type /S |
| [Table 97 – Entries in a Reference Dictionary](lib/ISO_32000/Table_97-Entries_in_a_Reference_Dictionary.rakumod) | /F /Page /ID |
| [Table 98 – Entries in an Optional Content Group Dictionary](lib/ISO_32000/Table_98-Entries_in_an_Optional_Content_Group_Dictionary.rakumod) | /Type /Name /Intent /Usage |
| [Table 99 – Entries in an Optional Content Membership Dictionary](lib/ISO_32000/Table_99-Entries_in_an_Optional_Content_Membership_Dictionary.rakumod) | /Type /OCGs /P /VE |
| [Table 100 – Entries in the Optional Content Properties Dictionary](lib/ISO_32000/Table_100-Entries_in_the_Optional_Content_Properties_Dictionary.rakumod) | /OCGs /D /Configs |
| [Table 101 – Entries in an Optional Content Configuration Dictionary](lib/ISO_32000/Table_101-Entries_in_an_Optional_Content_Configuration_Dictionary.rakumod) | /Name /Creator /BaseState /ON /OFF /Intent /AS /Order /ListMode /RBGroups /Locked |
| [Table 102 – Entries in an Optional Content Usage Dictionary](lib/ISO_32000/Table_102-Entries_in_an_Optional_Content_Usage_Dictionary.rakumod) | /CreatorInfo /Language /Export /Zoom /Print /View /User /PageElement |
| [Table 103 – Entries in a Usage Application Dictionary](lib/ISO_32000/Table_103-Entries_in_a_Usage_Application_Dictionary.rakumod) | /Event /OCGs /Category |
| [Table 111 – Entries in a Type 1 font dictionary](lib/ISO_32000/Table_111-Entries_in_a_Type_1_font_dictionary.rakumod) | /Type /Subtype /Name /BaseFont /FirstChar /LastChar /Widths /FontDescriptor /Encoding /ToUnicode |
| [Table 112 – Entries in a Type 3 font dictionary](lib/ISO_32000/Table_112-Entries_in_a_Type_3_font_dictionary.rakumod) | /Type /Subtype /Name /FontBBox /FontMatrix /CharProcs /Encoding /FirstChar /LastChar /Widths /FontDescriptor /Resources /ToUnicode |
| [Table 114 – Entries in an encoding dictionary](lib/ISO_32000/Table_114-Entries_in_an_encoding_dictionary.rakumod) | /Type /BaseEncoding /Differences |
| [Table 116 – Entries in a CIDSystemInfo dictionary](lib/ISO_32000/Table_116-Entries_in_a_CIDSystemInfo_dictionary.rakumod) | /Registry /Ordering /Supplement |
| [Table 117 – Entries in a CIDFont dictionary](lib/ISO_32000/Table_117-Entries_in_a_CIDFont_dictionary.rakumod) | /Type /Subtype /BaseFont /CIDSystemInfo /FontDescriptor /DW /W /DW2 /W2 /CIDToGIDMap |
| [Table 120 – Additional entries in a CMap stream dictionary](lib/ISO_32000/Table_120-Additional_entries_in_a_CMap_stream_dictionary.rakumod) | /Type /CMapName /CIDSystemInfo /WMode /UseCMap |
| [Table 121 – Entries in a Type 0 font dictionary](lib/ISO_32000/Table_121-Entries_in_a_Type_0_font_dictionary.rakumod) | /Type /Subtype /BaseFont /Encoding /DescendantFonts /ToUnicode |
| [Table 122 – Entries common to all font descriptors](lib/ISO_32000/Table_122-Entries_common_to_all_font_descriptors.rakumod) | /Type /FontName /FontFamily /FontStretch /FontWeight /Flags /FontBBox /ItalicAngle /Ascent /Descent /Leading /CapHeight /XHeight /StemV /StemH /AvgWidth /MaxWidth /MissingWidth /FontFile /FontFile2 /FontFile3 /CharSet |
| [Table 124 – Additional font descriptor entries for CIDFonts](lib/ISO_32000/Table_124-Additional_font_descriptor_entries_for_CIDFonts.rakumod) | /Style /Lang /FD /CIDSet |
| [Table 126 – Embedded font organization for various font types](lib/ISO_32000/Table_126-Embedded_font_organization_for_various_font_types.rakumod) | /FontFile /FontFile2 /FontFile3 |
| [Table 127 – Additional entries in an embedded font stream dictionary](lib/ISO_32000/Table_127-Additional_entries_in_an_embedded_font_stream_dictionary.rakumod) | /Length1 /Length2 /Length3 /Subtype /Metadata |
| [Table 130 – Entries in a type 1 halftone dictionary](lib/ISO_32000/Table_130-Entries_in_a_type_1_halftone_dictionary.rakumod) | /Type /HalftoneType /HalftoneName /Frequency /Angle /SpotFunction /AccurateScreens /TransferFunction |
| [Table 131 – Additional entries specific to a type 6 halftone dictionary](lib/ISO_32000/Table_131-Additional_entries_specific_to_a_type_6_halftone_dictionary.rakumod) | /Type /HalftoneType /HalftoneName /Width /Height /TransferFunction |
| [Table 132 – Additional entries specific to a type 10 halftone dictionary](lib/ISO_32000/Table_132-Additional_entries_specific_to_a_type_10_halftone_dictionary.rakumod) | /Type /HalftoneType /HalftoneName /Xsquare /Ysquare /TransferFunction |
| [Table 133 – Additional entries specific to a type 16 halftone dictionary](lib/ISO_32000/Table_133-Additional_entries_specific_to_a_type_16_halftone_dictionary.rakumod) | /Type /HalftoneType /HalftoneName /Width /Height /Width2 /Height2 /TransferFunction |
| [Table 134 – Entries in a type 5 halftone dictionary](lib/ISO_32000/Table_134-Entries_in_a_type_5_halftone_dictionary.rakumod) | /Type /HalftoneType /HalftoneName /Default |
| [Table 144 – Entries in a soft-mask dictionary](lib/ISO_32000/Table_144-Entries_in_a_soft-mask_dictionary.rakumod) | /Type /S /G /BC /TR |
| [Table 146 – Additional entry in a soft-mask image dictionary](lib/ISO_32000/Table_146-Additional_entry_in_a_soft-mask_image_dictionary.rakumod) | /Matte |
| [Table 147 – Additional entries specific to a transparency group attributes dictionary](lib/ISO_32000/Table_147-Additional_entries_specific_to_a_transparency_group_attributes_dictionary.rakumod) | /S /CS /I /K |
| [Table 150 – Entries in a viewer preferences dictionary](lib/ISO_32000/Table_150-Entries_in_a_viewer_preferences_dictionary.rakumod) | /HideToolbar /HideMenubar /HideWindowUI /FitWindow /CenterWindow /DisplayDocTitle /NonFullScreenPageMode /Direction /ViewArea /ViewClip /PrintArea /PrintClip /PrintScaling /Duplex /PickTrayByPDFSize /PrintPageRange /NumCopies |
| [Table 152 – Entries in the outline dictionary](lib/ISO_32000/Table_152-Entries_in_the_outline_dictionary.rakumod) | /Type /First /Last /Count |
| [Table 153 – Entries in an outline item dictionary](lib/ISO_32000/Table_153-Entries_in_an_outline_item_dictionary.rakumod) | /Title /Parent /Prev /Next /First /Last /Count /Dest /A /SE /C /F |
| [Table 155 – Entries in a collection dictionary](lib/ISO_32000/Table_155-Entries_in_a_collection_dictionary.rakumod) | /Type /Schema /D /View /Sort |
| [Table 156 – Entries in a collection schema dictionary](lib/ISO_32000/Table_156-Entries_in_a_collection_schema_dictionary.rakumod) | /Type |
| [Table 157 – Entries in a collection field dictionary](lib/ISO_32000/Table_157-Entries_in_a_collection_field_dictionary.rakumod) | /Type /Subtype /N /O /V /E |
| [Table 158 – Entries in a collection sort dictionary](lib/ISO_32000/Table_158-Entries_in_a_collection_sort_dictionary.rakumod) | /Type /S /A |
| [Table 159 – Entries in a page label dictionary](lib/ISO_32000/Table_159-Entries_in_a_page_label_dictionary.rakumod) | /Type /S /P /St |
| [Table 160 – Entries in a thread dictionary](lib/ISO_32000/Table_160-Entries_in_a_thread_dictionary.rakumod) | /Type /F /I |
| [Table 161 – Entries in a bead dictionary](lib/ISO_32000/Table_161-Entries_in_a_bead_dictionary.rakumod) | /Type /T /N /V /P /R |
| [Table 162 – Entries in a transition dictionary](lib/ISO_32000/Table_162-Entries_in_a_transition_dictionary.rakumod) | /Type /S /D /Dm /M /Di /SS /B |
| [Table 163 – Entries in a navigation node dictionary](lib/ISO_32000/Table_163-Entries_in_a_navigation_node_dictionary.rakumod) | /Type /NA /PA /Next /Prev /Dur |
| [Table 164 – Entries common to all annotation dictionaries](lib/ISO_32000/Table_164-Entries_common_to_all_annotation_dictionaries.rakumod) | /Type /Subtype /Rect /Contents /P /NM /M /F /AP /AS /Border /C /StructParent /OC |
| [Table 166 – Entries in a border style dictionary](lib/ISO_32000/Table_166-Entries_in_a_border_style_dictionary.rakumod) | /Type /W /S /D |
| [Table 167 – Entries in a border effect dictionary](lib/ISO_32000/Table_167-Entries_in_a_border_effect_dictionary.rakumod) | /S /I |
| [Table 168 – Entries in an appearance dictionary](lib/ISO_32000/Table_168-Entries_in_an_appearance_dictionary.rakumod) | /N /R /D |
| [Table 170 – Additional entries specific to markup annotations](lib/ISO_32000/Table_170-Additional_entries_specific_to_markup_annotations.rakumod) | /T /Popup /CA /RC /CreationDate /IRT /Subj /RT /IT /ExData |
| [Table 172 – Additional entries specific to a text annotation](lib/ISO_32000/Table_172-Additional_entries_specific_to_a_text_annotation.rakumod) | /Subtype /Open /Name /State /StateModel |
| [Table 173 – Additional entries specific to a link annotation](lib/ISO_32000/Table_173-Additional_entries_specific_to_a_link_annotation.rakumod) | /Subtype /A /Dest /H /PA /QuadPoints /BS |
| [Table 174 – Additional entries specific to a free text annotation](lib/ISO_32000/Table_174-Additional_entries_specific_to_a_free_text_annotation.rakumod) | /Subtype /DA /Q /RC /DS /CL /IT /BE /RD /BS /LE |
| [Table 175 – Additional entries specific to a line annotation](lib/ISO_32000/Table_175-Additional_entries_specific_to_a_line_annotation.rakumod) | /Subtype /L /BS /LE /IC /LL /LLE /Cap /IT /LLO /CP /Measure /CO |
| [Table 177 – Additional entries specific to a square or circle annotation](lib/ISO_32000/Table_177-Additional_entries_specific_to_a_square_or_circle_annotation.rakumod) | /Subtype /BS /IC /BE /RD |
| [Table 178 – Additional entries specific to a polygon or polyline annotation](lib/ISO_32000/Table_178-Additional_entries_specific_to_a_polygon_or_polyline_annotation.rakumod) | /Subtype /Vertices /LE /BS /IC /BE /IT /Measure |
| [Table 179 – Additional entries specific to text markup annotations](lib/ISO_32000/Table_179-Additional_entries_specific_to_text_markup_annotations.rakumod) | /Subtype /QuadPoints |
| [Table 180 – Additional entries specific to a caret annotation](lib/ISO_32000/Table_180-Additional_entries_specific_to_a_caret_annotation.rakumod) | /Subtype /RD /Sy |
| [Table 181 – Additional entries specific to a rubber stamp annotation](lib/ISO_32000/Table_181-Additional_entries_specific_to_a_rubber_stamp_annotation.rakumod) | /Subtype /Name |
| [Table 182 – Additional entries specific to an ink annotation](lib/ISO_32000/Table_182-Additional_entries_specific_to_an_ink_annotation.rakumod) | /Subtype /InkList /BS |
| [Table 183 – Additional entries specific to a pop-up annotation](lib/ISO_32000/Table_183-Additional_entries_specific_to_a_pop-up_annotation.rakumod) | /Subtype /Parent /Open |
| [Table 184 – Additional entries specific to a file attachment annotation](lib/ISO_32000/Table_184-Additional_entries_specific_to_a_file_attachment_annotation.rakumod) | /Subtype /FS /Name |
| |
## dist_zef-dwarring-PDF-ISO_32000.md
## Chunk 2 of 10
[Table 185 – Additional entries specific to a sound annotation](lib/ISO_32000/Table_185-Additional_entries_specific_to_a_sound_annotation.rakumod) | /Subtype /Sound /Name |
| [Table 186 – Additional entries specific to a movie annotation](lib/ISO_32000/Table_186-Additional_entries_specific_to_a_movie_annotation.rakumod) | /Subtype /T /Movie /A |
| [Table 187 – Additional entries specific to a screen annotation](lib/ISO_32000/Table_187-Additional_entries_specific_to_a_screen_annotation.rakumod) | /Subtype /T /MK /A /AA |
| [Table 188 – Additional entries specific to a widget annotation](lib/ISO_32000/Table_188-Additional_entries_specific_to_a_widget_annotation.rakumod) | /Subtype /H /MK /A /AA /BS /Parent |
| [Table 189 – Entries in an appearance characteristics dictionary](lib/ISO_32000/Table_189-Entries_in_an_appearance_characteristics_dictionary.rakumod) | /R /BC /BG /CA /RC /AC /I /RI /IX /IF /TP |
| [Table 190 – Additional entries specific to a watermark annotation](lib/ISO_32000/Table_190-Additional_entries_specific_to_a_watermark_annotation.rakumod) | /Subtype /FixedPrint |
| [Table 191 – Entries in a fixed print dictionary](lib/ISO_32000/Table_191-Entries_in_a_fixed_print_dictionary.rakumod) | /Type /Matrix /H /V |
| [Table 192 – Additional entries specific to a redaction annotation](lib/ISO_32000/Table_192-Additional_entries_specific_to_a_redaction_annotation.rakumod) | /Subtype /QuadPoints /IC /RO /OverlayText /Repeat /DA /Q |
| [Table 193 – Entries common to all action dictionaries](lib/ISO_32000/Table_193-Entries_common_to_all_action_dictionaries.rakumod) | /Type /S /Next |
| [Table 194 – Entries in an annotation’s additional-actions dictionary](lib/ISO_32000/Table_194-Entries_in_an_annotations_additional-actions_dictionary.rakumod) | /E /X /D /U /Fo /Bl /PO /PC /PV /PI |
| [Table 195 – Entries in a page object’s additional-actions dictionary](lib/ISO_32000/Table_195-Entries_in_a_page_objects_additional-actions_dictionary.rakumod) | /O /C |
| [Table 196 – Entries in a form field’s additional-actions dictionary](lib/ISO_32000/Table_196-Entries_in_a_form_fields_additional-actions_dictionary.rakumod) | /K /F /V /C |
| [Table 197 – Entries in the document catalog’s additional-actions dictionary](lib/ISO_32000/Table_197-Entries_in_the_document_catalogs_additional-actions_dictionary.rakumod) | /WC /WS /DS /WP /DP |
| [Table 199 – Additional entries specific to a go-to action](lib/ISO_32000/Table_199-Additional_entries_specific_to_a_go-to_action.rakumod) | /S /D |
| [Table 200 – Additional entries specific to a remote go-to action](lib/ISO_32000/Table_200-Additional_entries_specific_to_a_remote_go-to_action.rakumod) | /S /F /D /NewWindow |
| [Table 201 – Additional entries specific to an embedded go-to action](lib/ISO_32000/Table_201-Additional_entries_specific_to_an_embedded_go-to_action.rakumod) | /S /F /D /NewWindow /T |
| [Table 202 – Entries specific to a target dictionary](lib/ISO_32000/Table_202-Entries_specific_to_a_target_dictionary.rakumod) | /R /N /P /A /T |
| [Table 203 – Additional entries specific to a launch action](lib/ISO_32000/Table_203-Additional_entries_specific_to_a_launch_action.rakumod) | /S /F /Win /Mac /Unix /NewWindow |
| [Table 204 – Entries in a Windows launch parameter dictionary](lib/ISO_32000/Table_204-Entries_in_a_Windows_launch_parameter_dictionary.rakumod) | /F /D /O /P |
| [Table 205 – Additional entries specific to a thread action](lib/ISO_32000/Table_205-Additional_entries_specific_to_a_thread_action.rakumod) | /S /F /D /B |
| [Table 206 – Additional entries specific to a URI action](lib/ISO_32000/Table_206-Additional_entries_specific_to_a_URI_action.rakumod) | /S /URI /IsMap |
| [Table 207 – Entry in a URI dictionary](lib/ISO_32000/Table_207-Entry_in_a_URI_dictionary.rakumod) | /Base |
| [Table 208 – Additional entries specific to a sound action](lib/ISO_32000/Table_208-Additional_entries_specific_to_a_sound_action.rakumod) | /S /Sound /Volume /Synchronous /Repeat /Mix |
| [Table 209 – Additional entries specific to a movie action](lib/ISO_32000/Table_209-Additional_entries_specific_to_a_movie_action.rakumod) | /S /Annotation /T /Operation |
| [Table 210 – Additional entries specific to a hide action](lib/ISO_32000/Table_210-Additional_entries_specific_to_a_hide_action.rakumod) | /S /T /H |
| [Table 212 – Additional entries specific to named actions](lib/ISO_32000/Table_212-Additional_entries_specific_to_named_actions.rakumod) | /S /N |
| [Table 213 – Additional entries specific to a set-OCG-state action](lib/ISO_32000/Table_213-Additional_entries_specific_to_a_set-OCG-state_action.rakumod) | /S /State /PreserveRB |
| [Table 214 – Additional entries specific to a rendition action](lib/ISO_32000/Table_214-Additional_entries_specific_to_a_rendition_action.rakumod) | /S /R /AN /OP /JS |
| [Table 215 – Additional entries specific to a transition action](lib/ISO_32000/Table_215-Additional_entries_specific_to_a_transition_action.rakumod) | /S /Trans |
| [Table 216 – Additional entries specific to a go-to-3D-view action](lib/ISO_32000/Table_216-Additional_entries_specific_to_a_go-to-ThreeD-view_action.rakumod) | /S /TA /V |
| [Table 217 – Additional entries specific to a JavaScript action](lib/ISO_32000/Table_217-Additional_entries_specific_to_a_JavaScript_action.rakumod) | /S /JS |
| [Table 218 – Entries in the interactive form dictionary](lib/ISO_32000/Table_218-Entries_in_the_interactive_form_dictionary.rakumod) | /Fields /NeedAppearances /SigFlags /CO /DR /DA /Q /XFA |
| [Table 220 – Entries common to all field dictionaries](lib/ISO_32000/Table_220-Entries_common_to_all_field_dictionaries.rakumod) | /FT /Parent /Kids /T /TU /TM /Ff /V /DV /AA |
| [Table 222 – Additional entries common to all fields containing variable text](lib/ISO_32000/Table_222-Additional_entries_common_to_all_fields_containing_variable_text.rakumod) | /DA /Q /DS /RV |
| [Table 227 – Additional entry specific to check box and radio button fields](lib/ISO_32000/Table_227-Additional_entry_specific_to_check_box_and_radio_button_fields.rakumod) | /Opt |
| [Table 229 – Additional entry specific to a text field](lib/ISO_32000/Table_229-Additional_entry_specific_to_a_text_field.rakumod) | /MaxLen |
| [Table 231 – Additional entries specific to a choice field](lib/ISO_32000/Table_231-Additional_entries_specific_to_a_choice_field.rakumod) | /Opt /TI /I |
| [Table 232 – Additional entries specific to a signature field](lib/ISO_32000/Table_232-Additional_entries_specific_to_a_signature_field.rakumod) | /Lock /SV |
| [Table 233 – Entries in a signature field lock dictionary](lib/ISO_32000/Table_233-Entries_in_a_signature_field_lock_dictionary.rakumod) | /Type /Action /Fields |
| [Table 234 – Entries in a signature field seed value dictionary](lib/ISO_32000/Table_234-Entries_in_a_signature_field_seed_value_dictionary.rakumod) | /Type /Ff /Filter /SubFilter /DigestMethod /V /Cert /Reasons /MDP /TimeStamp /LegalAttestation /AddRevInfo |
| [Table 235 – Entries in a certificate seed value dictionary](lib/ISO_32000/Table_235-Entries_in_a_certificate_seed_value_dictionary.rakumod) | /Type /Ff /Subject /SubjectDN /KeyUsage /Issuer /OID /URL /URLType |
| [Table 236 – Additional entries specific to a submit-form action](lib/ISO_32000/Table_236-Additional_entries_specific_to_a_submit-form_action.rakumod) | /S /F /Fields /Flags |
| [Table 238 – Additional entries specific to a reset-form action](lib/ISO_32000/Table_238-Additional_entries_specific_to_a_reset-form_action.rakumod) | /S /Fields /Flags |
| [Table 240 – Additional entries specific to an import-data action](lib/ISO_32000/Table_240-Additional_entries_specific_to_an_import-data_action.rakumod) | /S /F |
| [Table 241 – Entry in the FDF trailer dictionary](lib/ISO_32000/Table_241-Entry_in_the_FDF_trailer_dictionary.rakumod) | /Root |
| [Table 242 – Entries in the FDF catalog dictionary](lib/ISO_32000/Table_242-Entries_in_the_FDF_catalog_dictionary.rakumod) | /Version /FDF |
| [Table 243 – Entries in the FDF dictionary](lib/ISO_32000/Table_243-Entries_in_the_FDF_dictionary.rakumod) | /F /ID /Fields /Status /Pages /Encoding /Annots /Differences /Target /EmbeddedFDFs /JavaScript |
| [Table 244 – Additional entry in an embedded file stream dictionary for an encrypted FDF file](lib/ISO_32000/Table_244-Additional_entry_in_an_embedded_file_stream_dictionary_for_an_encrypted_FDF_file.rakumod) | /EncryptionRevision |
| [Table 245 – Entries in the JavaScript dictionary](lib/ISO_32000/Table_245-Entries_in_the_JavaScript_dictionary.rakumod) | /Before /After /AfterPermsReady /Doc |
| [Table 246 – Entries in an FDF field dictionary](lib/ISO_32000/Table_246-Entries_in_an_FDF_field_dictionary.rakumod) | /Kids /T /V /Ff /SetFf /ClrFf /F /SetF /ClrF /AP /APRef /IF /Opt /A /AA /RV |
| [Table 247 – Entries in an icon fit dictionary](lib/ISO_32000/Table_247-Entries_in_an_icon_fit_dictionary.rakumod) | /SW /S /A /FB |
| [Table 248 – Entries in an FDF page dictionary](lib/ISO_32000/Table_248-Entries_in_an_FDF_page_dictionary.rakumod) | /Templates /Info |
| [Table 249 – Entries in an FDF template dictionary](lib/ISO_32000/Table_249-Entries_in_an_FDF_template_dictionary.rakumod) | /TRef /Fields /Rename |
| [Table 250 – Entries in an FDF named page reference dictionary](lib/ISO_32000/Table_250-Entries_in_an_FDF_named_page_reference_dictionary.rakumod) | /Name /F |
| [Table 251 – Additional entry for annotation dictionaries in an FDF file](lib/ISO_32000/Table_251-Additional_entry_for_annotation_dictionaries_in_an_FDF_file.rakumod) | /Page |
| [Table 252 – Entries in a signature dictionary](lib/ISO_32000/Table_252-Entries_in_a_signature_dictionary.rakumod) | /Type /Filter /SubFilter /Contents /Cert /ByteRange /Reference /Changes /Name /M /Location /Reason /ContactInfo /R /V /Prop\_Build /Prop\_AuthTime /Prop\_AuthType |
| [Table 253 – Entries in a signature reference dictionary](lib/ISO_32000/Table_253-Entries_in_a_signature_reference_dictionary.rakumod) | /Type /TransformMethod /TransformParams /Data /DigestMethod |
| [Table 254 – Entries in the DocMDP transform parameters dictionary](lib/ISO_32000/Table_254-Entries_in_the_DocMDP_transform_parameters_dictionary.rakumod) | /Type /P /V |
| [Table 255 – Entries in the UR transform parameters dictionary](lib/ISO_32000/Table_255-Entries_in_the_UR_transform_parameters_dictionary.rakumod) | /Type /Document /Msg /V /Annots /Form /Signature /EF /P |
| [Table 256 – Entries in the FieldMDP transform parameters dictionary](lib/ISO_32000/Table_256-Entries_in_the_FieldMDP_transform_parameters_dictionary.rakumod) | /Type /Action /Fields /V |
| [Table 258 – Entries in a permissions dictionary](lib/ISO_32000/Table_258-Entries_in_a_permissions_dictionary.rakumod) | /DocMDP /UR3 |
| [Table 259 – Entries in a legal attestation dictionary](lib/ISO_32000/Table_259-Entries_in_a_legal_attestation_dictionary.rakumod) | /JavaScriptActions /LaunchActions /URIActions /MovieActions /SoundActions /HideAnnotationActions /GoToRemoteActions /AlternateImages /ExternalStreams /TrueTypeFonts /ExternalRefXobjects /ExternalOPIdicts /NonEmbeddedFonts /DevDepGS\_OP /DevDepGS\_HT /DevDepGS\_TR /DevDepGS\_UCR /DevDepGS\_BG /DevDepGS\_FL /Annotations /OptionalContent /Attestation |
| [Table 260 – Entries in a viewport dictionary](lib/ISO_32000/Table_260-Entries_in_a_viewport_dictionary.rakumod) | /Type /BBox /Name /Measure |
| [Table 261 – Entries in a measure dictionary](lib/ISO_32000/Table_261-Entries_in_a_measure_dictionary.rakumod) | /Type /Subtype |
| [Table 262 – Additional entries in a rectilinear measure dictionary](lib/ISO_32000/Table_262-Additional_entries_in_a_rectilinear_measure_dictionary.rakumod) | /R /X /Y /D /A /T /S /O /CYX |
| [Table 263 – Entries in a number format dictionary](lib/ISO_32000/Table_263-Entries_in_a_number_format_dictionary.rakumod) | /Type /U /C /F /D /FD /RT /RD /PS /SS /O |
| [Table 264 – Entries common to all requirement dictionaries](lib/ISO_32000/Table_264-Entries_common_to_all_requirement_dictionaries.rakumod) | /Type /S /RH |
| [Table 265 – Entries in a requirement handler dictionary](lib/ISO_32000/Table_265-Entries_in_a_requirement_handler_dictionary.rakumod) | /Type /S /Script |
| [Table 266 – Entries common to all rendition dictionaries](lib/ISO_32000/Table_266-Entries_common_to_all_rendition_dictionaries.rakumod) | /Type /S /N /MH /BE |
| [Table 267 – Entries in a rendition MH/BE dictionary](lib/ISO_32000/Table_267-Entries_in_a_rendition_MH-BE_dictionary.rakumod) | /C |
| [Table 268 – Entries in a media criteria dictionary](lib/ISO_32000/Table_268-Entries_in_a_media_criteria_dictionary.rakumod) | /Type /A /C /O /S /R /D /Z /V /P /L |
| [Table 269 – Entries in a minimum bit depth dictionary](lib/ISO_32000/Table_269-Entries_in_a_minimum_bit_depth_dictionary.rakumod) | /Type /V /M |
| [Table 270 – Entries in a minimum screen size dictionary](lib/ISO_32000/Table_270-Entries_in_a_minimum_screen_size_dictionary.rakumod) | /Type /V /M |
| [Table 271 – Additional entries in a media rendition dictionary](lib/ISO_32000/Table_271-Additional_entries_in_a_media_rendition_dictionary.rakumod) | /C /P /SP |
| [Table 272 – Additional entries specific to a selector rendition dictionary](lib/ISO_32000/Table_272-Additional_entries_specific_to_a_selector_rendition_dictionary.rakumod) | /R |
| [Table 273 – Entries common to all media clip dictionaries](lib/ISO_32000/Table_273-Entries_common_to_all_media_clip_dictionaries.rakumod) | /Type /S /N |
| [Table 274 – Additional entries in a media clip data dictionary](lib/ISO_32000/Table_274-Additional_entries_in_a_media_clip_data_dictionary.rakumod) | /D /CT /P /Alt /PL /MH /BE |
| [Table 275 – Entries in a media permissions dictionary](lib/ISO_32000/Table_275-Entries_in_a_media_permissions_dictionary.rakumod) | /Type /TF |
| [Table 276 – Entries in a media clip data MH/BE dictionary](lib/ISO_32000/Table_276-Entries_in_a_media_clip_data_MH-BE_dictionary.rakumod) | /BU |
| [Table 277 – Additional entries in a media clip section dictionary](lib/ISO_32000/Table_277-Additional_entries_in_a_media_clip_section_dictionary.rakumod) | /D /Alt /MH /BE |
| [Table 278 – Entries in a media clip section MH/BE dictionary](lib/ISO_32000/Table_278-Entries_in_a_media_clip_section_MH-BE_dictionary.rakumod) | /B /E |
| [Table 279 – Entries in a media play parameters dictionary](lib/ISO_32000/Table_279-Entries_in_a_media_play_parameters_dictionary.rakumod) | /Type /PL /MH /BE |
| [Table 280 – Entries in a media play parameters MH/BE dictionary](lib/ISO_32000/Table_280-Entries_in_a_media_play_parameters_MH-BE_dictionary.rakumod) | /V /C /F /D /A /RC |
| [Table 281 – Entries in a media duration dictionary](lib/ISO_32000/Table_281-Entries_in_a_media_duration_dictionary.rakumod) | /Type /S /T |
| [Table 282 – Entries in a media screen parameters dictionary](lib/ISO_32000/Table_282-Entries_in_a_media_screen_parameters_dictionary.rakumod) | /Type /MH /BE |
| [Table 283 – Entries in a media screen parameters MH/BE dictionary](lib/ISO_32000/Table_283-Entries_in_a_media_screen_parameters_MH-BE_dictionary.rakumod) | /W /B /O /M /F |
| [Table 284 – Entries in a floating window parameters dictionary](lib/ISO_32000/Table_284-Entries_in_a_floating_window_parameters_dictionary.rakumod) | /Type /D /RT /P /O /T /UC /R /TT |
| [Table 285 – Entries common to all media offset dictionaries](lib/ISO_32000/Table_285-Entries_common_to_all_media_offset_dictionaries.rakumod) | /Type /S |
| [Table 286 – Additional entries in a media offset time dictionary](lib/ISO_32000/Table_286-Additional_entries_in_a_media_offset_time_dictionary.rakumod) | /T |
| [Table 287 – Additional entries in a media offset frame dictionary](lib/ISO_32000/Table_287-Additional_entries_in_a_media_offset_frame_dictionary.rakumod) | /F |
| [Table 288 – Additional entries in a media offset marker dictionary](lib/ISO_32000/Table_288-Additional_entries_in_a_media_offset_marker_dictionary.rakumod) | /M |
| [Table 289 – Entries in a timespan dictionary](lib/ISO_32000/Table_289-Entries_in_a_timespan_dictionary.rakumod) | /Type /S /V |
| [Table 290 – Entries in a media players dictionary](lib/ISO_32000/Table_290-Entries_in_a_media_players_dictionary.rakumod) | /Type /MU /A /NU |
| [Table 291 – Entries in a media player info dictionary](lib/ISO_32000/Table_291-Entries_in_a_media_player_info_dictionary.rakumod) | /Type /PID /MH /BE |
| [Table 292 – Entries in a software identifier dictionary](lib/ISO_32000/Table_292-Entries_in_a_software_identifier_dictionary.rakumod) | /Type /U /L /LI /H /HI /OS |
| [Table 294 – Additional entries specific to a sound object](lib/ISO_32000/Table_294-Additional_entries_specific_to_a_sound_object.rakumod) | /Type /R /C /B /E /CO /CP |
| [Table 295 – Entries in a movie dictionary](lib/ISO_32000/Table_295-Entries_in_a_movie_dictionary.rakumod) | /F /Aspect /Rotate /Poster |
| [Table 296 – Entries in a movie activation dictionary](lib/ISO_32000/Table_296-Entries_in_a_movie_activation_dictionary.rakumod) | /Start /Duration /Rate /Volume /ShowControls /Mode /Synchronous /FWScale /FWPosition |
| [Table 297 – Entries in a slideshow dictionary](lib/ISO_32000/Table_297-Entries_in_a_slideshow_dictionary.rakumod) | /Type /Subtype /Resources /StartResource |
| [Table 298 – Additional entries specific to a 3D annotation](lib/ISO_32000/Table_298-Additional_entries_specific_to_a_ThreeD_annotation.rakumod) | /Subtype /3DD /3DV /3DA /3DI /3DB |
| [Table 299 – Entries in a 3D activation dictionary](lib/ISO_32000/Table_299-Entries_in_a_ThreeD_activation_dictionary.rakumod) | /A /AIS /D /DIS /TB /NP |
| [Table 300 – Entries in a 3D stream dictionary](lib/ISO_32000/Table_300-Entries_in_a_ThreeD_stream_dictionary.rakumod) | /Type /Subtype /VA /DV /Resources /OnInstantiate /AN |
| [Table 301 – Entries in an 3D animation style dictionary](lib/ISO_32000/Table_301-Entries_in_an_ThreeD_animation_style_dictionary.rakumod) | /Type /Subtype /PC /TM |
| [Table 303 – Entries in a 3D reference dictionary](lib/ISO_32000/Table_303-Entries_in_a_ThreeD_reference_dictionary.rakumod) | /Type /3DD |
| [Table 304 – Entries in a 3D view dictionary](lib/ISO_32000/Table_304-Entries_in_a_ThreeD_view_dictionary.rakumod) | /Type /XN /IN /MS /C2W /U3DPath /CO /P /O /BG /RM /LS /SA /NA /NR |
| [Table 305 – Entries in a projection dictionary](lib/ISO_32000/Table_305-Entries_in_a_projection_dictionary.rakumod) | /Subtype /CS /F /N /FOV /PS /OS /OB |
| [Table 306 – Entries in a 3D background dictionary](lib/ISO_32000/Table_306-Entries_in_a_ThreeD_background_dictionary.rakumod) | /Type /Subtype /CS /C /EA |
| [Table 307 – Entries in a render mode dictionary](lib/ISO_32000/Table_307-Entries_in_a_render_mode_dictionary.rakumod) | /Type /Subtype /AC /FC /O /CV |
| [Table 309 – Entries in a 3D lighting scheme dictionary](lib/ISO_32000/Table_309-Entries_in_a_ThreeD_lighting_scheme_dictionary.rakumod) | /Type /Subtype |
| [Table 311 – Entries in a 3D cross section dictionary](lib/ISO_32000/Table_311-Entries_in_a_ThreeD_cross_section_dictionary.rakumod) | /Type /C /O /PO /PC /IV /IC |
| [Table 312 – Entries in a 3D node dictionary](lib/ISO_32000/Table_312-Entries_in_a_ThreeD_node_dictionary.rakumod) | /Type /N /O /V /M |
| [Table 313 – Entries in an external data dictionary used to markup 3D annotations](lib/ISO_32000/Table_313-Entries_in_an_external_data_dictionary_used_to_markup_ThreeD_annotations.rakumod) | /Type /Subtype /MD5 /3DA /3DV |
| [Table 315 – Additional entries in a metadata stream dictionary](lib/ISO_32000/Table_315-Additional_entries_in_a_metadata_stream_dictionary.rakumod) | /Type /Subtype |
| [Table 316 – Additional entry for components having metadata](lib/ISO_32000/Table_316-Additional_entry_for_components_having_metadata.rakumod) | /Metadata |
| [Table 317 – Entries in the document information dictionary](lib/ISO_32000/Table_317-Entries_in_the_document_information_dictionary.rakumod) | /Title /Author /Subject /Keywords /Creator /Producer /CreationDate /ModDate /Trapped |
| [Table 318 – Entries in a page-piece dictionary](lib/ISO_32000/Table_318-Entries_in_a_page-piece_dictionary.rakumod) | |
| [Table 319 – Entries in an data dictionary](lib/ISO_32000/Table_319-Entries_in_an_data_dictionary.rakumod) | /LastModified /Private |
| [Table 321 – Entries in the mark information dictionary](lib/ISO_32000/Table_321-Entries_in_the_mark_information_dictionary.rakumod) | /Marked /UserProperties /Suspects |
| [Table 322 – Entries in the structure tree root](lib/ISO_32000/Table_322-Entries_in_the_structure_tree_root.rakumod) | /Type /K /IDTree /ParentTree /ParentTreeNextKey /RoleMap /ClassMap |
| [Table 323 – Entries in a structure element dictionary](lib/ISO_32000/Table_323-Entries_in_a_structure_element_dictionary.rakumod) | /Type /S /P /ID /Pg /K /A /C /R /T /Lang /Alt /E /ActualText |
| [Table 324 – Entries in a marked-content reference dictionary](lib/ISO_32000/Table_324-Entries_in_a_marked-content_reference_dictionary.rakumod) | /Type /Pg /Stm /StmOwn /MCID |
| [Table 325 – Entries in an object reference dictionary](lib/ISO_32000/Table_325-Entries_in_an_object_reference_dictionary.rakumod) | /Type /Pg /Obj |
| [Table 326 – Additional dictionary entries for structure element access](lib/ISO_32000/Table_326-Additional_dictionary_entries_for_structure_element_access.rakumod) | /StructParent /StructParents |
| [Table 327 – Entry common to all attribute object dictionaries](lib/ISO_32000/Table_327-Entry_common_to_all_attribute_object_dictionaries.rakumod) | /O |
| [Table 328 – Additional entries in an attribute object dictionary for user properties](lib/ISO_32000/Table_328-Additional_entries_in_an_attribute_object_dictionary_for_user_properties.rakumod) | /O /P |
| [Table 329 – Entries in a user property dictionary](lib/ISO_32000/Table_329-Entries_in_a_user_property_dictionary.rakumod) | /N /V /F /H |
| [Table 330 – Property list entries for artifacts](lib/ISO_32000/Table_330-Property_list_entries_for_artifacts.rakumod) | /Type /BBox /Attached /Subtype |
| [Table 343 – Standard layout attributes common to all standard structure types](lib/ISO_32000/Table_343-Standard_layout_attributes_common_to_all_standard_structure_types.rakumod) | /Placement /WritingMode /BackgroundColor /BorderColor /BorderStyle /BorderThickness /Padding /Color |
| [Table 344 – Additional standard layout attributes specific to block-level structure elements](lib/ISO_32000/Table_344-Additional_standard_layout_attributes_specific_to_block-level_structure_elements.rakumod) | /SpaceBefore /SpaceAfter /StartIndent /EndIndent /TextIndent /TextAlign /BBox /Width /Height /BlockAlign /InlineAlign /TBorderStyle /TPadding |
| [Table 345 – Standard layout attributes specific to inline-level structure elements](lib/ISO_32000/Table_345-Standard_layout_attributes_specific_to_inline-level_structure_elements.rakumod) | /BaselineShift /LineHeight /TextDecorationColor /TextDecorationThickness /TextDecorationType /RubyAlign /RubyPosition /GlyphOrientationVertical |
| [Table 346 – Standard column attributes](lib/ISO_32000/Table_346-Standard_column_attributes.rakumod) | /ColumnCount /ColumnGap /ColumnWidths |
| [Table 347 – Standard list attribute](lib/ISO_32000/Table_347-Standard_list_attribute.rakumod) | /ListNumbering |
| [Table 348 – PrintField attributes](lib/ISO_32000/Table_348-PrintField_attributes.rakumod) | /Role /checked /Desc |
| [Table 349 – Standard table attributes](lib/ISO_32000/Table_349-Standard_table_attributes.rakumod) | /RowSpan /ColSpan /Headers /Scope /Summary |
| [Table 350 – Entries in the Web Capture information dictionary](lib/ISO_32000/Table_350-Entries_in_the_Web_Capture_information_dictionary.rakumod) | /V /C |
| [Table 352 – Entries common to all Web Capture content sets](lib/ISO_32000/Table_352-Entries_common_to_all_Web_Capture_content_sets.rakumod) | /Type /S /ID /O /SI /CT /TS |
| [Table 353 – Additional entries specific to a Web Capture page set](lib/ISO_32000/Table_353-Additional_entries_specific_to_a_Web_Capture_page_set.rakumod) | /S /T /TID |
| [Table 354 – Additional entries specific to a Web Capture image set](lib/ISO_32000/Table_354-Additional_entries_specific_to_a_Web_Capture_image_set.rakumod) | /S /R |
| [Table 355 – Entries in a source information dictionary](lib/ISO_32000/Table_355-Entries_in_a_source_information_dictionary.rakumod) | /AU /TS /E /S /C |
| [Table 356 – Entries in a URL alias dictionary](lib/ISO_32000/Table_356-Entries_in_a_URL_alias_dictionary.rakumod) | /U /C |
| [Table 357 – Entries in a Web Capture command dictionary](lib/ISO_32000/Table_357-Entries_in_a_Web_Capture_command_dictionary.rakumod) | /URL /L /F /P /CT /H /S |
| [Table 359 – Entries in a Web Capture command settings dictionary](lib/ISO_32000/Table_359-Entries_in_a_Web_Capture_command_settings_dictionary.rakumod) | /G /C |
| [Table 360 – Entries in a box colour information dictionary](lib/ISO_32000/Table_360-Entries_in_a_box_colour_information_dictionary.rakumod) | /CropBox /BleedBox /TrimBox /ArtBox |
| [Table 361 – Entries in a box style dictionary](lib/ISO_32000/Table_361-Entries_in_a_box_style_dictionary.rak |
## dist_zef-dwarring-PDF-ISO_32000.md
## Chunk 3 of 10
umod) | /C /W /S /D |
| [Table 362 – Additional entries specific to a printer’s mark annotation](lib/ISO_32000/Table_362-Additional_entries_specific_to_a_printers_mark_annotation.rakumod) | /Subtype /MN |
| [Table 363 – Additional entries specific to a printer’s mark form dictionary](lib/ISO_32000/Table_363-Additional_entries_specific_to_a_printers_mark_form_dictionary.rakumod) | /MarkStyle /Colorants |
| [Table 364 – Entries in a separation dictionary](lib/ISO_32000/Table_364-Entries_in_a_separation_dictionary.rakumod) | /Pages /DeviceColorant /ColorSpace |
| [Table 365 – Entries in an output intent dictionary](lib/ISO_32000/Table_365-Entries_in_an_output_intent_dictionary.rakumod) | /Type /S /OutputCondition /OutputConditionIdentifier /RegistryName /Info /DestOutputProfile |
| [Table 366 – Additional entries specific to a trap network annotation](lib/ISO_32000/Table_366-Additional_entries_specific_to_a_trap_network_annotation.rakumod) | /Subtype /LastModified /Version /AnnotStates /FontFauxing |
| [Table 367 – Additional entries specific to a trap network appearance stream](lib/ISO_32000/Table_367-Additional_entries_specific_to_a_trap_network_appearance_stream.rakumod) | /PCM /SeparationColorNames /TrapRegions /TrapStyles |
| [Table 368 – Entry in an OPI version dictionary](lib/ISO_32000/Table_368-Entry_in_an_OPI_version_dictionary.rakumod) | /versionNumber |
## Entry to role mappings
| Entry | ISO\_32000 Roles |
| --- | --- |
| /3DA | [Table 298 – Additional entries specific to a 3D annotation](lib/ISO_32000/Table_298-Additional_entries_specific_to_a_ThreeD_annotation.rakumod) [Table 313 – Entries in an external data dictionary used to markup 3D annotations](lib/ISO_32000/Table_313-Entries_in_an_external_data_dictionary_used_to_markup_ThreeD_annotations.rakumod) |
| /3DB | [Table 298 – Additional entries specific to a 3D annotation](lib/ISO_32000/Table_298-Additional_entries_specific_to_a_ThreeD_annotation.rakumod) |
| /3DD | [Table 298 – Additional entries specific to a 3D annotation](lib/ISO_32000/Table_298-Additional_entries_specific_to_a_ThreeD_annotation.rakumod) [Table 303 – Entries in a 3D reference dictionary](lib/ISO_32000/Table_303-Entries_in_a_ThreeD_reference_dictionary.rakumod) |
| /3DI | [Table 298 – Additional entries specific to a 3D annotation](lib/ISO_32000/Table_298-Additional_entries_specific_to_a_ThreeD_annotation.rakumod) |
| /3DV | [Table 298 – Additional entries specific to a 3D annotation](lib/ISO_32000/Table_298-Additional_entries_specific_to_a_ThreeD_annotation.rakumod) [Table 313 – Entries in an external data dictionary used to markup 3D annotations](lib/ISO_32000/Table_313-Entries_in_an_external_data_dictionary_used_to_markup_ThreeD_annotations.rakumod) |
| /A | [Table 153 – Entries in an outline item dictionary](lib/ISO_32000/Table_153-Entries_in_an_outline_item_dictionary.rakumod) [Table 158 – Entries in a collection sort dictionary](lib/ISO_32000/Table_158-Entries_in_a_collection_sort_dictionary.rakumod) [Table 173 – Additional entries specific to a link annotation](lib/ISO_32000/Table_173-Additional_entries_specific_to_a_link_annotation.rakumod) [Table 186 – Additional entries specific to a movie annotation](lib/ISO_32000/Table_186-Additional_entries_specific_to_a_movie_annotation.rakumod) [Table 187 – Additional entries specific to a screen annotation](lib/ISO_32000/Table_187-Additional_entries_specific_to_a_screen_annotation.rakumod) [Table 188 – Additional entries specific to a widget annotation](lib/ISO_32000/Table_188-Additional_entries_specific_to_a_widget_annotation.rakumod) [Table 202 – Entries specific to a target dictionary](lib/ISO_32000/Table_202-Entries_specific_to_a_target_dictionary.rakumod) [Table 246 – Entries in an FDF field dictionary](lib/ISO_32000/Table_246-Entries_in_an_FDF_field_dictionary.rakumod) [Table 247 – Entries in an icon fit dictionary](lib/ISO_32000/Table_247-Entries_in_an_icon_fit_dictionary.rakumod) [Table 262 – Additional entries in a rectilinear measure dictionary](lib/ISO_32000/Table_262-Additional_entries_in_a_rectilinear_measure_dictionary.rakumod) [Table 268 – Entries in a media criteria dictionary](lib/ISO_32000/Table_268-Entries_in_a_media_criteria_dictionary.rakumod) [Table 280 – Entries in a media play parameters MH/BE dictionary](lib/ISO_32000/Table_280-Entries_in_a_media_play_parameters_MH-BE_dictionary.rakumod) [Table 290 – Entries in a media players dictionary](lib/ISO_32000/Table_290-Entries_in_a_media_players_dictionary.rakumod) [Table 299 – Entries in a 3D activation dictionary](lib/ISO_32000/Table_299-Entries_in_a_ThreeD_activation_dictionary.rakumod) [Table 323 – Entries in a structure element dictionary](lib/ISO_32000/Table_323-Entries_in_a_structure_element_dictionary.rakumod) |
| /AA | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) [Table 187 – Additional entries specific to a screen annotation](lib/ISO_32000/Table_187-Additional_entries_specific_to_a_screen_annotation.rakumod) [Table 188 – Additional entries specific to a widget annotation](lib/ISO_32000/Table_188-Additional_entries_specific_to_a_widget_annotation.rakumod) [Table 220 – Entries common to all field dictionaries](lib/ISO_32000/Table_220-Entries_common_to_all_field_dictionaries.rakumod) [Table 246 – Entries in an FDF field dictionary](lib/ISO_32000/Table_246-Entries_in_an_FDF_field_dictionary.rakumod) |
| /AC | [Table 189 – Entries in an appearance characteristics dictionary](lib/ISO_32000/Table_189-Entries_in_an_appearance_characteristics_dictionary.rakumod) [Table 307 – Entries in a render mode dictionary](lib/ISO_32000/Table_307-Entries_in_a_render_mode_dictionary.rakumod) |
| /AIS | [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) [Table 299 – Entries in a 3D activation dictionary](lib/ISO_32000/Table_299-Entries_in_a_ThreeD_activation_dictionary.rakumod) |
| /AN | [Table 214 – Additional entries specific to a rendition action](lib/ISO_32000/Table_214-Additional_entries_specific_to_a_rendition_action.rakumod) [Table 300 – Entries in a 3D stream dictionary](lib/ISO_32000/Table_300-Entries_in_a_ThreeD_stream_dictionary.rakumod) |
| /AP | [Table 31 – Entries in the name dictionary](lib/ISO_32000/Table_31-Entries_in_the_name_dictionary.rakumod) [Table 164 – Entries common to all annotation dictionaries](lib/ISO_32000/Table_164-Entries_common_to_all_annotation_dictionaries.rakumod) [Table 246 – Entries in an FDF field dictionary](lib/ISO_32000/Table_246-Entries_in_an_FDF_field_dictionary.rakumod) |
| /APRef | [Table 246 – Entries in an FDF field dictionary](lib/ISO_32000/Table_246-Entries_in_an_FDF_field_dictionary.rakumod) |
| /AS | [Table 101 – Entries in an Optional Content Configuration Dictionary](lib/ISO_32000/Table_101-Entries_in_an_Optional_Content_Configuration_Dictionary.rakumod) [Table 164 – Entries common to all annotation dictionaries](lib/ISO_32000/Table_164-Entries_common_to_all_annotation_dictionaries.rakumod) |
| /AU | [Table 355 – Entries in a source information dictionary](lib/ISO_32000/Table_355-Entries_in_a_source_information_dictionary.rakumod) |
| /AccurateScreens | [Table 130 – Entries in a type 1 halftone dictionary](lib/ISO_32000/Table_130-Entries_in_a_type_1_halftone_dictionary.rakumod) |
| /AcroForm | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) |
| /Action | [Table 233 – Entries in a signature field lock dictionary](lib/ISO_32000/Table_233-Entries_in_a_signature_field_lock_dictionary.rakumod) [Table 256 – Entries in the FieldMDP transform parameters dictionary](lib/ISO_32000/Table_256-Entries_in_the_FieldMDP_transform_parameters_dictionary.rakumod) |
| /ActualText | [Table 323 – Entries in a structure element dictionary](lib/ISO_32000/Table_323-Entries_in_a_structure_element_dictionary.rakumod) |
| /AddRevInfo | [Table 234 – Entries in a signature field seed value dictionary](lib/ISO_32000/Table_234-Entries_in_a_signature_field_seed_value_dictionary.rakumod) |
| /After | [Table 245 – Entries in the JavaScript dictionary](lib/ISO_32000/Table_245-Entries_in_the_JavaScript_dictionary.rakumod) |
| /AfterPermsReady | [Table 245 – Entries in the JavaScript dictionary](lib/ISO_32000/Table_245-Entries_in_the_JavaScript_dictionary.rakumod) |
| /Alt | [Table 274 – Additional entries in a media clip data dictionary](lib/ISO_32000/Table_274-Additional_entries_in_a_media_clip_data_dictionary.rakumod) [Table 277 – Additional entries in a media clip section dictionary](lib/ISO_32000/Table_277-Additional_entries_in_a_media_clip_section_dictionary.rakumod) [Table 323 – Entries in a structure element dictionary](lib/ISO_32000/Table_323-Entries_in_a_structure_element_dictionary.rakumod) |
| /Alternate | [Table 66 – Additional Entries Specific to an ICC Profile Stream Dictionary](lib/ISO_32000/Table_66-Additional_Entries_Specific_to_an_ICC_Profile_Stream_Dictionary.rakumod) |
| /AlternateImages | [Table 259 – Entries in a legal attestation dictionary](lib/ISO_32000/Table_259-Entries_in_a_legal_attestation_dictionary.rakumod) |
| /AlternatePresentations | [Table 31 – Entries in the name dictionary](lib/ISO_32000/Table_31-Entries_in_the_name_dictionary.rakumod) |
| /Alternates | [Table 89 – Additional Entries Specific to an Image Dictionary](lib/ISO_32000/Table_89-Additional_Entries_Specific_to_an_Image_Dictionary.rakumod) |
| /Angle | [Table 130 – Entries in a type 1 halftone dictionary](lib/ISO_32000/Table_130-Entries_in_a_type_1_halftone_dictionary.rakumod) |
| /AnnotStates | [Table 366 – Additional entries specific to a trap network annotation](lib/ISO_32000/Table_366-Additional_entries_specific_to_a_trap_network_annotation.rakumod) |
| /Annotation | [Table 209 – Additional entries specific to a movie action](lib/ISO_32000/Table_209-Additional_entries_specific_to_a_movie_action.rakumod) |
| /Annotations | [Table 259 – Entries in a legal attestation dictionary](lib/ISO_32000/Table_259-Entries_in_a_legal_attestation_dictionary.rakumod) |
| /Annots | [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) [Table 243 – Entries in the FDF dictionary](lib/ISO_32000/Table_243-Entries_in_the_FDF_dictionary.rakumod) [Table 255 – Entries in the UR transform parameters dictionary](lib/ISO_32000/Table_255-Entries_in_the_UR_transform_parameters_dictionary.rakumod) |
| /AntiAlias | [Table 78 – Entries Common to All Shading Dictionaries](lib/ISO_32000/Table_78-Entries_Common_to_All_Shading_Dictionaries.rakumod) |
| /ArtBox | [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) [Table 360 – Entries in a box colour information dictionary](lib/ISO_32000/Table_360-Entries_in_a_box_colour_information_dictionary.rakumod) |
| /Ascent | [Table 122 – Entries common to all font descriptors](lib/ISO_32000/Table_122-Entries_common_to_all_font_descriptors.rakumod) |
| /Aspect | [Table 295 – Entries in a movie dictionary](lib/ISO_32000/Table_295-Entries_in_a_movie_dictionary.rakumod) |
| /Attached | [Table 330 – Property list entries for artifacts](lib/ISO_32000/Table_330-Property_list_entries_for_artifacts.rakumod) |
| /Attestation | [Table 259 – Entries in a legal attestation dictionary](lib/ISO_32000/Table_259-Entries_in_a_legal_attestation_dictionary.rakumod) |
| /AuthEvent | [Table 25 – Entries common to all crypt filter dictionaries](lib/ISO_32000/Table_25-Entries_common_to_all_crypt_filter_dictionaries.rakumod) |
| /Author | [Table 317 – Entries in the document information dictionary](lib/ISO_32000/Table_317-Entries_in_the_document_information_dictionary.rakumod) |
| /AvgWidth | [Table 122 – Entries common to all font descriptors](lib/ISO_32000/Table_122-Entries_common_to_all_font_descriptors.rakumod) |
| /B | [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) [Table 162 – Entries in a transition dictionary](lib/ISO_32000/Table_162-Entries_in_a_transition_dictionary.rakumod) [Table 205 – Additional entries specific to a thread action](lib/ISO_32000/Table_205-Additional_entries_specific_to_a_thread_action.rakumod) [Table 278 – Entries in a media clip section MH/BE dictionary](lib/ISO_32000/Table_278-Entries_in_a_media_clip_section_MH-BE_dictionary.rakumod) [Table 283 – Entries in a media screen parameters MH/BE dictionary](lib/ISO_32000/Table_283-Entries_in_a_media_screen_parameters_MH-BE_dictionary.rakumod) [Table 294 – Additional entries specific to a sound object](lib/ISO_32000/Table_294-Additional_entries_specific_to_a_sound_object.rakumod) |
| /BBox | [Table 75 – Additional Entries Specific to a Type 1 Pattern Dictionary](lib/ISO_32000/Table_75-Additional_Entries_Specific_to_a_Type_1_Pattern_Dictionary.rakumod) [Table 78 – Entries Common to All Shading Dictionaries](lib/ISO_32000/Table_78-Entries_Common_to_All_Shading_Dictionaries.rakumod) [Table 95 – Additional Entries Specific to a Type 1 Form Dictionary](lib/ISO_32000/Table_95-Additional_Entries_Specific_to_a_Type_1_Form_Dictionary.rakumod) [Table 260 – Entries in a viewport dictionary](lib/ISO_32000/Table_260-Entries_in_a_viewport_dictionary.rakumod) [Table 330 – Property list entries for artifacts](lib/ISO_32000/Table_330-Property_list_entries_for_artifacts.rakumod) [Table 344 – Additional standard layout attributes specific to block-level structure elements](lib/ISO_32000/Table_344-Additional_standard_layout_attributes_specific_to_block-level_structure_elements.rakumod) |
| /BC | [Table 144 – Entries in a soft-mask dictionary](lib/ISO_32000/Table_144-Entries_in_a_soft-mask_dictionary.rakumod) [Table 189 – Entries in an appearance characteristics dictionary](lib/ISO_32000/Table_189-Entries_in_an_appearance_characteristics_dictionary.rakumod) |
| /BE | [Table 174 – Additional entries specific to a free text annotation](lib/ISO_32000/Table_174-Additional_entries_specific_to_a_free_text_annotation.rakumod) [Table 177 – Additional entries specific to a square or circle annotation](lib/ISO_32000/Table_177-Additional_entries_specific_to_a_square_or_circle_annotation.rakumod) [Table 178 – Additional entries specific to a polygon or polyline annotation](lib/ISO_32000/Table_178-Additional_entries_specific_to_a_polygon_or_polyline_annotation.rakumod) [Table 266 – Entries common to all rendition dictionaries](lib/ISO_32000/Table_266-Entries_common_to_all_rendition_dictionaries.rakumod) [Table 274 – Additional entries in a media clip data dictionary](lib/ISO_32000/Table_274-Additional_entries_in_a_media_clip_data_dictionary.rakumod) [Table 277 – Additional entries in a media clip section dictionary](lib/ISO_32000/Table_277-Additional_entries_in_a_media_clip_section_dictionary.rakumod) [Table 279 – Entries in a media play parameters dictionary](lib/ISO_32000/Table_279-Entries_in_a_media_play_parameters_dictionary.rakumod) [Table 282 – Entries in a media screen parameters dictionary](lib/ISO_32000/Table_282-Entries_in_a_media_screen_parameters_dictionary.rakumod) [Table 291 – Entries in a media player info dictionary](lib/ISO_32000/Table_291-Entries_in_a_media_player_info_dictionary.rakumod) |
| /BG | [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) [Table 189 – Entries in an appearance characteristics dictionary](lib/ISO_32000/Table_189-Entries_in_an_appearance_characteristics_dictionary.rakumod) [Table 304 – Entries in a 3D view dictionary](lib/ISO_32000/Table_304-Entries_in_a_ThreeD_view_dictionary.rakumod) |
| /BG2 | [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) |
| /BM | [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) |
| /BS | [Table 173 – Additional entries specific to a link annotation](lib/ISO_32000/Table_173-Additional_entries_specific_to_a_link_annotation.rakumod) [Table 174 – Additional entries specific to a free text annotation](lib/ISO_32000/Table_174-Additional_entries_specific_to_a_free_text_annotation.rakumod) [Table 175 – Additional entries specific to a line annotation](lib/ISO_32000/Table_175-Additional_entries_specific_to_a_line_annotation.rakumod) [Table 177 – Additional entries specific to a square or circle annotation](lib/ISO_32000/Table_177-Additional_entries_specific_to_a_square_or_circle_annotation.rakumod) [Table 178 – Additional entries specific to a polygon or polyline annotation](lib/ISO_32000/Table_178-Additional_entries_specific_to_a_polygon_or_polyline_annotation.rakumod) [Table 182 – Additional entries specific to an ink annotation](lib/ISO_32000/Table_182-Additional_entries_specific_to_an_ink_annotation.rakumod) [Table 188 – Additional entries specific to a widget annotation](lib/ISO_32000/Table_188-Additional_entries_specific_to_a_widget_annotation.rakumod) |
| /BU | [Table 276 – Entries in a media clip data MH/BE dictionary](lib/ISO_32000/Table_276-Entries_in_a_media_clip_data_MH-BE_dictionary.rakumod) |
| /Background | [Table 78 – Entries Common to All Shading Dictionaries](lib/ISO_32000/Table_78-Entries_Common_to_All_Shading_Dictionaries.rakumod) |
| /BackgroundColor | [Table 343 – Standard layout attributes common to all standard structure types](lib/ISO_32000/Table_343-Standard_layout_attributes_common_to_all_standard_structure_types.rakumod) |
| /Base | [Table 207 – Entry in a URI dictionary](lib/ISO_32000/Table_207-Entry_in_a_URI_dictionary.rakumod) |
| /BaseEncoding | [Table 114 – Entries in an encoding dictionary](lib/ISO_32000/Table_114-Entries_in_an_encoding_dictionary.rakumod) |
| /BaseFont | [Table 111 – Entries in a Type 1 font dictionary](lib/ISO_32000/Table_111-Entries_in_a_Type_1_font_dictionary.rakumod) [Table 117 – Entries in a CIDFont dictionary](lib/ISO_32000/Table_117-Entries_in_a_CIDFont_dictionary.rakumod) [Table 121 – Entries in a Type 0 font dictionary](lib/ISO_32000/Table_121-Entries_in_a_Type_0_font_dictionary.rakumod) |
| /BaseState | [Table 101 – Entries in an Optional Content Configuration Dictionary](lib/ISO_32000/Table_101-Entries_in_an_Optional_Content_Configuration_Dictionary.rakumod) |
| /BaseVersion | [Table 50 – Entries in a developer extensions dictionary](lib/ISO_32000/Table_50-Entries_in_a_developer_extensions_dictionary.rakumod) |
| /BaselineShift | [Table 345 – Standard layout attributes specific to inline-level structure elements](lib/ISO_32000/Table_345-Standard_layout_attributes_specific_to_inline-level_structure_elements.rakumod) |
| /Before | [Table 245 – Entries in the JavaScript dictionary](lib/ISO_32000/Table_245-Entries_in_the_JavaScript_dictionary.rakumod) |
| /BitsPerComponent | [Table 8 – Optional parameters for LZWDecode and FlateDecode filters](lib/ISO_32000/Table_8-Optional_parameters_for_LZWDecode_and_FlateDecode_filters.rakumod) [Table 82 – Additional Entries Specific to a Type 4 Shading Dictionary](lib/ISO_32000/Table_82-Additional_Entries_Specific_to_a_Type_4_Shading_Dictionary.rakumod) [Table 83 – Additional Entries Specific to a Type 5 Shading Dictionary](lib/ISO_32000/Table_83-Additional_Entries_Specific_to_a_Type_5_Shading_Dictionary.rakumod) [Table 84 – Additional Entries Specific to a Type 6 Shading Dictionary](lib/ISO_32000/Table_84-Additional_Entries_Specific_to_a_Type_6_Shading_Dictionary.rakumod) [Table 89 – Additional Entries Specific to an Image Dictionary](lib/ISO_32000/Table_89-Additional_Entries_Specific_to_an_Image_Dictionary.rakumod) |
| /BitsPerCoordinate | [Table 82 – Additional Entries Specific to a Type 4 Shading Dictionary](lib/ISO_32000/Table_82-Additional_Entries_Specific_to_a_Type_4_Shading_Dictionary.rakumod) [Table 83 – Additional Entries Specific to a Type 5 Shading Dictionary](lib/ISO_32000/Table_83-Additional_Entries_Specific_to_a_Type_5_Shading_Dictionary.rakumod) [Table 84 – Additional Entries Specific to a Type 6 Shading Dictionary](lib/ISO_32000/Table_84-Additional_Entries_Specific_to_a_Type_6_Shading_Dictionary.rakumod) |
| /BitsPerFlag | [Table 82 – Additional Entries Specific to a Type 4 Shading Dictionary](lib/ISO_32000/Table_82-Additional_Entries_Specific_to_a_Type_4_Shading_Dictionary.rakumod) [Table 84 – Additional Entries Specific to a Type 6 Shading Dictionary](lib/ISO_32000/Table_84-Additional_Entries_Specific_to_a_Type_6_Shading_Dictionary.rakumod) |
| /BitsPerSample | [Table 39 – Additional entries specific to a type 0 function dictionary](lib/ISO_32000/Table_39-Additional_entries_specific_to_a_type_0_function_dictionary.rakumod) |
| /Bl | [Table 194 – Entries in an annotation’s additional-actions dictionary](lib/ISO_32000/Table_194-Entries_in_an_annotations_additional-actions_dictionary.rakumod) |
| /BlackIs1 | [Table 11 – Optional parameters for the CCITTFaxDecode filter](lib/ISO_32000/Table_11-Optional_parameters_for_the_CCITTFaxDecode_filter.rakumod) |
| /BlackPoint | [Table 63 – Entries in a CalGray Colour Space Dictionary](lib/ISO_32000/Table_63-Entries_in_a_CalGray_Colour_Space_Dictionary.rakumod) [Table 64 – Entries in a CalRGB Colour Space Dictionary](lib/ISO_32000/Table_64-Entries_in_a_CalRGB_Colour_Space_Dictionary.rakumod) [Table 65 – Entries in a Lab Colour Space Dictionary](lib/ISO_32000/Table_65-Entries_in_a_Lab_Colour_Space_Dictionary.rakumod) |
| /BleedBox | [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) [Table 360 – Entries in a box colour information dictionary](lib/ISO_32000/Table_360-Entries_in_a_box_colour_information_dictionary.rakumod) |
| /BlockAlign | [Table 344 – Additional standard layout attributes specific to block-level structure elements](lib/ISO_32000/Table_344-Additional_standard_layout_attributes_specific_to_block-level_structure_elements.rakumod) |
| /Border | [Table 164 – Entries common to all annotation dictionaries](lib/ISO_32000/Table_164-Entries_common_to_all_annotation_dictionaries.rakumod) |
| /BorderColor | [Table 343 – Standard layout attributes common to all standard structure types](lib/ISO_32000/Table_343-Standard_layout_attributes_common_to_all_standard_structure_types.rakumod) |
| /BorderStyle | [Table 343 – Standard layout attributes common to all standard structure types](lib/ISO_32000/Table_343-Standard_layout_attributes_common_to_all_standard_structure_types.rakumod) |
| /BorderThickness | [Table 343 – Standard layout attributes common to all standard structure types](lib/ISO_32000/Table_343-Standard_layout_attributes_common_to_all_standard_structure_types.rakumod) |
| /Bounds | [Table 41 – Additional entries specific to a type 3 function dictionary](lib/ISO_32000/Table_41-Additional_entries_specific_to_a_type_3_function_dictionary.rakumod) |
| /BoxColorInfo | [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) |
| /ByteRange | [Table 252 – Entries in a signature dictionary](lib/ISO_32000/Table_252-Entries_in_a_signature_dictionary.rakumod) |
| /C | [Table 153 – Entries in an outline item dictionary](lib/ISO_32000/Table_153-Entries_in_an_outline_item_dictionary.rakumod) [Table 164 – Entries common to all annotation dictionaries](lib/ISO_32000/Table_164-Entries_common_to_all_annotation_dictionaries.rakumod) [Table 195 – Entries in a page object’s additional-actions dictionary](lib/ISO_32000/Table_195-Entries_in_a_page_objects_additional-actions_dictionary.rakumod) [Table 196 – Entries in a form field’s additional-actions dictionary](lib/ISO_32000/Table_196-Entries_in_a_form_fields_additional-actions_dictionary.rakumod) [Table 263 – Entries in a number format dictionary](lib/ISO_32000/Table_263-Entries_in_a_number_format_dictionary.rakumod) [Table 267 – Entries in a rendition MH/BE dictionary](lib/ISO_32000/Table_267-Entries_in_a_rendition_MH-BE_dictionary.rakumod) [Table 268 – Entries in a media criteria dictionary](lib/ISO_32000/Table_268-Entries_in_a_media_criteria_dictionary.rakumod) [Table 271 – Additional entries in a media rendition dictionary](lib/ISO_32000/Table_271-Additional_entries_in_a_media_rendition_dictionary.rakumod) [Table 280 – Entries in a media play parameters MH/BE dictionary](lib/ISO_32000/Table_280-Entries_in_a_media_play_parameters_MH-BE_dictionary.rakumod) [Table 294 – Additional entries specific to a sound object](lib/ISO_32000/Table_294-Additional_entries_specific_to_a_sound_object.rakumod) [Table 306 – Entries in a 3D background dictionary](lib/ISO_32000/Table_306-Entries_in_a_ThreeD_background_dictionary.rakumod) [Table 311 – Entries in a 3D cross section dictionary](lib/ISO_32000/Table_311-Entries_in_a_ThreeD_cross_section_dictionary.rakumod) [Table 323 – Entries in a structure element dictionary](lib/ISO_32000/Table_323-Entries_in_a_structure_element_dictionary.rakumod) [Table 350 – Entries in the Web Capture information dictionary](lib/ISO_32000/Table_350-Entries_in_the_Web_Capture_information_dictionary.rakumod) [Table 355 – Entries in a source information dictionary](lib/ISO_32000/Table_355-Entries_in_a_source_information_dictionary.rakumod) [Table 356 – Entries in a URL alias dictionary](lib/ISO_32000/Table_356-Entries_in_a_URL_alias_dictionary.rakumod) [Table 359 – Entries in a Web Capture command settings dictionary](lib/ISO_32000/Table_359-Entries_in_a_Web_Capture_command_settings_dictionary.rakumod) [Table 361 – Entries in a box style dictionary](lib/ISO_32000/Table_361-Entries_in_a_box_style_dictionary.rakumod) |
| /C0 | [Table 40 – Additional entries specific to a type 2 function dictionary](lib/ISO_32000/Table_40-Additional_entries_specific_to_a_type_2_function_dictionary.rakumod) |
| /C1 | [Table 40 – Additional entries specific to a type 2 function dictionary](lib/ISO_32000/Table_40-Additional_entries_specific_to_a_type_2_function_dictionary.rakumod) |
| /C2W | [Table 304 – Entries in a 3D view dictionary](lib/ISO_32000/Table_304-Entries_in_a_ThreeD_view_dictionary.rakumod) |
| /CA | [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO |
## dist_zef-dwarring-PDF-ISO_32000.md
## Chunk 4 of 10
_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) [Table 170 – Additional entries specific to markup annotations](lib/ISO_32000/Table_170-Additional_entries_specific_to_markup_annotations.rakumod) [Table 189 – Entries in an appearance characteristics dictionary](lib/ISO_32000/Table_189-Entries_in_an_appearance_characteristics_dictionary.rakumod) |
| /CF | [Table 20 – Entries common to all encryption dictionaries](lib/ISO_32000/Table_20-Entries_common_to_all_encryption_dictionaries.rakumod) |
| /CFM | [Table 25 – Entries common to all crypt filter dictionaries](lib/ISO_32000/Table_25-Entries_common_to_all_crypt_filter_dictionaries.rakumod) |
| /CI | [Table 44 – Entries in a file specification dictionary](lib/ISO_32000/Table_44-Entries_in_a_file_specification_dictionary.rakumod) |
| /CIDSet | [Table 124 – Additional font descriptor entries for CIDFonts](lib/ISO_32000/Table_124-Additional_font_descriptor_entries_for_CIDFonts.rakumod) |
| /CIDSystemInfo | [Table 117 – Entries in a CIDFont dictionary](lib/ISO_32000/Table_117-Entries_in_a_CIDFont_dictionary.rakumod) [Table 120 – Additional entries in a CMap stream dictionary](lib/ISO_32000/Table_120-Additional_entries_in_a_CMap_stream_dictionary.rakumod) |
| /CIDToGIDMap | [Table 117 – Entries in a CIDFont dictionary](lib/ISO_32000/Table_117-Entries_in_a_CIDFont_dictionary.rakumod) |
| /CL | [Table 174 – Additional entries specific to a free text annotation](lib/ISO_32000/Table_174-Additional_entries_specific_to_a_free_text_annotation.rakumod) |
| /CMapName | [Table 120 – Additional entries in a CMap stream dictionary](lib/ISO_32000/Table_120-Additional_entries_in_a_CMap_stream_dictionary.rakumod) |
| /CO | [Table 175 – Additional entries specific to a line annotation](lib/ISO_32000/Table_175-Additional_entries_specific_to_a_line_annotation.rakumod) [Table 218 – Entries in the interactive form dictionary](lib/ISO_32000/Table_218-Entries_in_the_interactive_form_dictionary.rakumod) [Table 294 – Additional entries specific to a sound object](lib/ISO_32000/Table_294-Additional_entries_specific_to_a_sound_object.rakumod) [Table 304 – Entries in a 3D view dictionary](lib/ISO_32000/Table_304-Entries_in_a_ThreeD_view_dictionary.rakumod) |
| /CP | [Table 175 – Additional entries specific to a line annotation](lib/ISO_32000/Table_175-Additional_entries_specific_to_a_line_annotation.rakumod) [Table 294 – Additional entries specific to a sound object](lib/ISO_32000/Table_294-Additional_entries_specific_to_a_sound_object.rakumod) |
| /CS | [Table 147 – Additional entries specific to a transparency group attributes dictionary](lib/ISO_32000/Table_147-Additional_entries_specific_to_a_transparency_group_attributes_dictionary.rakumod) [Table 305 – Entries in a projection dictionary](lib/ISO_32000/Table_305-Entries_in_a_projection_dictionary.rakumod) [Table 306 – Entries in a 3D background dictionary](lib/ISO_32000/Table_306-Entries_in_a_ThreeD_background_dictionary.rakumod) |
| /CT | [Table 274 – Additional entries in a media clip data dictionary](lib/ISO_32000/Table_274-Additional_entries_in_a_media_clip_data_dictionary.rakumod) [Table 352 – Entries common to all Web Capture content sets](lib/ISO_32000/Table_352-Entries_common_to_all_Web_Capture_content_sets.rakumod) [Table 357 – Entries in a Web Capture command dictionary](lib/ISO_32000/Table_357-Entries_in_a_Web_Capture_command_dictionary.rakumod) |
| /CTM | [Table 52 – Device-Independent Graphics State Parameters](lib/ISO_32000/Table_52-Device-Independent_Graphics_State_Parameters.rakumod) |
| /CV | [Table 307 – Entries in a render mode dictionary](lib/ISO_32000/Table_307-Entries_in_a_render_mode_dictionary.rakumod) |
| /CYX | [Table 262 – Additional entries in a rectilinear measure dictionary](lib/ISO_32000/Table_262-Additional_entries_in_a_rectilinear_measure_dictionary.rakumod) |
| /Cap | [Table 175 – Additional entries specific to a line annotation](lib/ISO_32000/Table_175-Additional_entries_specific_to_a_line_annotation.rakumod) |
| /CapHeight | [Table 122 – Entries common to all font descriptors](lib/ISO_32000/Table_122-Entries_common_to_all_font_descriptors.rakumod) |
| /Category | [Table 103 – Entries in a Usage Application Dictionary](lib/ISO_32000/Table_103-Entries_in_a_Usage_Application_Dictionary.rakumod) |
| /CenterWindow | [Table 150 – Entries in a viewer preferences dictionary](lib/ISO_32000/Table_150-Entries_in_a_viewer_preferences_dictionary.rakumod) |
| /Cert | [Table 234 – Entries in a signature field seed value dictionary](lib/ISO_32000/Table_234-Entries_in_a_signature_field_seed_value_dictionary.rakumod) [Table 252 – Entries in a signature dictionary](lib/ISO_32000/Table_252-Entries_in_a_signature_dictionary.rakumod) |
| /Changes | [Table 252 – Entries in a signature dictionary](lib/ISO_32000/Table_252-Entries_in_a_signature_dictionary.rakumod) |
| /CharProcs | [Table 112 – Entries in a Type 3 font dictionary](lib/ISO_32000/Table_112-Entries_in_a_Type_3_font_dictionary.rakumod) |
| /CharSet | [Table 122 – Entries common to all font descriptors](lib/ISO_32000/Table_122-Entries_common_to_all_font_descriptors.rakumod) |
| /CheckSum | [Table 46 – Entries in an embedded file parameter dictionary](lib/ISO_32000/Table_46-Entries_in_an_embedded_file_parameter_dictionary.rakumod) |
| /ClassMap | [Table 322 – Entries in the structure tree root](lib/ISO_32000/Table_322-Entries_in_the_structure_tree_root.rakumod) |
| /ClrF | [Table 246 – Entries in an FDF field dictionary](lib/ISO_32000/Table_246-Entries_in_an_FDF_field_dictionary.rakumod) |
| /ClrFf | [Table 246 – Entries in an FDF field dictionary](lib/ISO_32000/Table_246-Entries_in_an_FDF_field_dictionary.rakumod) |
| /ColSpan | [Table 349 – Standard table attributes](lib/ISO_32000/Table_349-Standard_table_attributes.rakumod) |
| /Collection | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) |
| /Color | [Table 343 – Standard layout attributes common to all standard structure types](lib/ISO_32000/Table_343-Standard_layout_attributes_common_to_all_standard_structure_types.rakumod) |
| /ColorSpace | [Table 33 – Entries in a resource dictionary](lib/ISO_32000/Table_33-Entries_in_a_resource_dictionary.rakumod) [Table 72 – Entries in a DeviceN Process Dictionary](lib/ISO_32000/Table_72-Entries_in_a_DeviceN_Process_Dictionary.rakumod) [Table 78 – Entries Common to All Shading Dictionaries](lib/ISO_32000/Table_78-Entries_Common_to_All_Shading_Dictionaries.rakumod) [Table 89 – Additional Entries Specific to an Image Dictionary](lib/ISO_32000/Table_89-Additional_Entries_Specific_to_an_Image_Dictionary.rakumod) [Table 364 – Entries in a separation dictionary](lib/ISO_32000/Table_364-Entries_in_a_separation_dictionary.rakumod) |
| /ColorTransform | [Table 13 – Optional parameter for the DCTDecode filter](lib/ISO_32000/Table_13-Optional_parameter_for_the_DCTDecode_filter.rakumod) |
| /Colorants | [Table 71 – Entries in a DeviceN Colour Space Attributes Dictionary](lib/ISO_32000/Table_71-Entries_in_a_DeviceN_Colour_Space_Attributes_Dictionary.rakumod) [Table 363 – Additional entries specific to a printer’s mark form dictionary](lib/ISO_32000/Table_363-Additional_entries_specific_to_a_printers_mark_form_dictionary.rakumod) |
| /Colors | [Table 8 – Optional parameters for LZWDecode and FlateDecode filters](lib/ISO_32000/Table_8-Optional_parameters_for_LZWDecode_and_FlateDecode_filters.rakumod) |
| /ColumnCount | [Table 346 – Standard column attributes](lib/ISO_32000/Table_346-Standard_column_attributes.rakumod) |
| /ColumnGap | [Table 346 – Standard column attributes](lib/ISO_32000/Table_346-Standard_column_attributes.rakumod) |
| /ColumnWidths | [Table 346 – Standard column attributes](lib/ISO_32000/Table_346-Standard_column_attributes.rakumod) |
| /Columns | [Table 8 – Optional parameters for LZWDecode and FlateDecode filters](lib/ISO_32000/Table_8-Optional_parameters_for_LZWDecode_and_FlateDecode_filters.rakumod) [Table 11 – Optional parameters for the CCITTFaxDecode filter](lib/ISO_32000/Table_11-Optional_parameters_for_the_CCITTFaxDecode_filter.rakumod) |
| /Components | [Table 72 – Entries in a DeviceN Process Dictionary](lib/ISO_32000/Table_72-Entries_in_a_DeviceN_Process_Dictionary.rakumod) |
| /Configs | [Table 100 – Entries in the Optional Content Properties Dictionary](lib/ISO_32000/Table_100-Entries_in_the_Optional_Content_Properties_Dictionary.rakumod) |
| /ContactInfo | [Table 252 – Entries in a signature dictionary](lib/ISO_32000/Table_252-Entries_in_a_signature_dictionary.rakumod) |
| /Contents | [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) [Table 164 – Entries common to all annotation dictionaries](lib/ISO_32000/Table_164-Entries_common_to_all_annotation_dictionaries.rakumod) [Table 252 – Entries in a signature dictionary](lib/ISO_32000/Table_252-Entries_in_a_signature_dictionary.rakumod) |
| /Coords | [Table 80 – Additional Entries Specific to a Type 2 Shading Dictionary](lib/ISO_32000/Table_80-Additional_Entries_Specific_to_a_Type_2_Shading_Dictionary.rakumod) [Table 81 – Additional Entries Specific to a Type 3 Shading Dictionary](lib/ISO_32000/Table_81-Additional_Entries_Specific_to_a_Type_3_Shading_Dictionary.rakumod) |
| /Count | [Table 29 – Required entries in a page tree node](lib/ISO_32000/Table_29-Required_entries_in_a_page_tree_node.rakumod) [Table 152 – Entries in the outline dictionary](lib/ISO_32000/Table_152-Entries_in_the_outline_dictionary.rakumod) [Table 153 – Entries in an outline item dictionary](lib/ISO_32000/Table_153-Entries_in_an_outline_item_dictionary.rakumod) |
| /CreationDate | [Table 46 – Entries in an embedded file parameter dictionary](lib/ISO_32000/Table_46-Entries_in_an_embedded_file_parameter_dictionary.rakumod) [Table 170 – Additional entries specific to markup annotations](lib/ISO_32000/Table_170-Additional_entries_specific_to_markup_annotations.rakumod) [Table 317 – Entries in the document information dictionary](lib/ISO_32000/Table_317-Entries_in_the_document_information_dictionary.rakumod) |
| /Creator | [Table 47 – Entries in a Mac OS file information dictionary](lib/ISO_32000/Table_47-Entries_in_a_Mac_OS_file_information_dictionary.rakumod) [Table 101 – Entries in an Optional Content Configuration Dictionary](lib/ISO_32000/Table_101-Entries_in_an_Optional_Content_Configuration_Dictionary.rakumod) [Table 317 – Entries in the document information dictionary](lib/ISO_32000/Table_317-Entries_in_the_document_information_dictionary.rakumod) |
| /CreatorInfo | [Table 102 – Entries in an Optional Content Usage Dictionary](lib/ISO_32000/Table_102-Entries_in_an_Optional_Content_Usage_Dictionary.rakumod) |
| /CropBox | [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) [Table 360 – Entries in a box colour information dictionary](lib/ISO_32000/Table_360-Entries_in_a_box_colour_information_dictionary.rakumod) |
| /D | [Table 49 – Entries in a collection subitem dictionary](lib/ISO_32000/Table_49-Entries_in_a_collection_subitem_dictionary.rakumod) [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) [Table 100 – Entries in the Optional Content Properties Dictionary](lib/ISO_32000/Table_100-Entries_in_the_Optional_Content_Properties_Dictionary.rakumod) [Table 155 – Entries in a collection dictionary](lib/ISO_32000/Table_155-Entries_in_a_collection_dictionary.rakumod) [Table 162 – Entries in a transition dictionary](lib/ISO_32000/Table_162-Entries_in_a_transition_dictionary.rakumod) [Table 166 – Entries in a border style dictionary](lib/ISO_32000/Table_166-Entries_in_a_border_style_dictionary.rakumod) [Table 168 – Entries in an appearance dictionary](lib/ISO_32000/Table_168-Entries_in_an_appearance_dictionary.rakumod) [Table 194 – Entries in an annotation’s additional-actions dictionary](lib/ISO_32000/Table_194-Entries_in_an_annotations_additional-actions_dictionary.rakumod) [Table 199 – Additional entries specific to a go-to action](lib/ISO_32000/Table_199-Additional_entries_specific_to_a_go-to_action.rakumod) [Table 200 – Additional entries specific to a remote go-to action](lib/ISO_32000/Table_200-Additional_entries_specific_to_a_remote_go-to_action.rakumod) [Table 201 – Additional entries specific to an embedded go-to action](lib/ISO_32000/Table_201-Additional_entries_specific_to_an_embedded_go-to_action.rakumod) [Table 204 – Entries in a Windows launch parameter dictionary](lib/ISO_32000/Table_204-Entries_in_a_Windows_launch_parameter_dictionary.rakumod) [Table 205 – Additional entries specific to a thread action](lib/ISO_32000/Table_205-Additional_entries_specific_to_a_thread_action.rakumod) [Table 262 – Additional entries in a rectilinear measure dictionary](lib/ISO_32000/Table_262-Additional_entries_in_a_rectilinear_measure_dictionary.rakumod) [Table 263 – Entries in a number format dictionary](lib/ISO_32000/Table_263-Entries_in_a_number_format_dictionary.rakumod) [Table 268 – Entries in a media criteria dictionary](lib/ISO_32000/Table_268-Entries_in_a_media_criteria_dictionary.rakumod) [Table 274 – Additional entries in a media clip data dictionary](lib/ISO_32000/Table_274-Additional_entries_in_a_media_clip_data_dictionary.rakumod) [Table 277 – Additional entries in a media clip section dictionary](lib/ISO_32000/Table_277-Additional_entries_in_a_media_clip_section_dictionary.rakumod) [Table 280 – Entries in a media play parameters MH/BE dictionary](lib/ISO_32000/Table_280-Entries_in_a_media_play_parameters_MH-BE_dictionary.rakumod) [Table 284 – Entries in a floating window parameters dictionary](lib/ISO_32000/Table_284-Entries_in_a_floating_window_parameters_dictionary.rakumod) [Table 299 – Entries in a 3D activation dictionary](lib/ISO_32000/Table_299-Entries_in_a_ThreeD_activation_dictionary.rakumod) [Table 361 – Entries in a box style dictionary](lib/ISO_32000/Table_361-Entries_in_a_box_style_dictionary.rakumod) |
| /DA | [Table 174 – Additional entries specific to a free text annotation](lib/ISO_32000/Table_174-Additional_entries_specific_to_a_free_text_annotation.rakumod) [Table 192 – Additional entries specific to a redaction annotation](lib/ISO_32000/Table_192-Additional_entries_specific_to_a_redaction_annotation.rakumod) [Table 218 – Entries in the interactive form dictionary](lib/ISO_32000/Table_218-Entries_in_the_interactive_form_dictionary.rakumod) [Table 222 – Additional entries common to all fields containing variable text](lib/ISO_32000/Table_222-Additional_entries_common_to_all_fields_containing_variable_text.rakumod) |
| /DIS | [Table 299 – Entries in a 3D activation dictionary](lib/ISO_32000/Table_299-Entries_in_a_ThreeD_activation_dictionary.rakumod) |
| /DL | [Table 5 – Entries common to all stream dictionaries](lib/ISO_32000/Table_5-Entries_common_to_all_stream_dictionaries.rakumod) |
| /DOS | [Table 44 – Entries in a file specification dictionary](lib/ISO_32000/Table_44-Entries_in_a_file_specification_dictionary.rakumod) |
| /DP | [Table 197 – Entries in the document catalog’s additional-actions dictionary](lib/ISO_32000/Table_197-Entries_in_the_document_catalogs_additional-actions_dictionary.rakumod) |
| /DR | [Table 218 – Entries in the interactive form dictionary](lib/ISO_32000/Table_218-Entries_in_the_interactive_form_dictionary.rakumod) |
| /DS | [Table 174 – Additional entries specific to a free text annotation](lib/ISO_32000/Table_174-Additional_entries_specific_to_a_free_text_annotation.rakumod) [Table 197 – Entries in the document catalog’s additional-actions dictionary](lib/ISO_32000/Table_197-Entries_in_the_document_catalogs_additional-actions_dictionary.rakumod) [Table 222 – Additional entries common to all fields containing variable text](lib/ISO_32000/Table_222-Additional_entries_common_to_all_fields_containing_variable_text.rakumod) |
| /DV | [Table 220 – Entries common to all field dictionaries](lib/ISO_32000/Table_220-Entries_common_to_all_field_dictionaries.rakumod) [Table 300 – Entries in a 3D stream dictionary](lib/ISO_32000/Table_300-Entries_in_a_ThreeD_stream_dictionary.rakumod) |
| /DW | [Table 117 – Entries in a CIDFont dictionary](lib/ISO_32000/Table_117-Entries_in_a_CIDFont_dictionary.rakumod) |
| /DW2 | [Table 117 – Entries in a CIDFont dictionary](lib/ISO_32000/Table_117-Entries_in_a_CIDFont_dictionary.rakumod) |
| /DamagedRowsBeforeError | [Table 11 – Optional parameters for the CCITTFaxDecode filter](lib/ISO_32000/Table_11-Optional_parameters_for_the_CCITTFaxDecode_filter.rakumod) |
| /Data | [Table 253 – Entries in a signature reference dictionary](lib/ISO_32000/Table_253-Entries_in_a_signature_reference_dictionary.rakumod) |
| /Decode | [Table 39 – Additional entries specific to a type 0 function dictionary](lib/ISO_32000/Table_39-Additional_entries_specific_to_a_type_0_function_dictionary.rakumod) [Table 82 – Additional Entries Specific to a Type 4 Shading Dictionary](lib/ISO_32000/Table_82-Additional_Entries_Specific_to_a_Type_4_Shading_Dictionary.rakumod) [Table 83 – Additional Entries Specific to a Type 5 Shading Dictionary](lib/ISO_32000/Table_83-Additional_Entries_Specific_to_a_Type_5_Shading_Dictionary.rakumod) [Table 84 – Additional Entries Specific to a Type 6 Shading Dictionary](lib/ISO_32000/Table_84-Additional_Entries_Specific_to_a_Type_6_Shading_Dictionary.rakumod) [Table 89 – Additional Entries Specific to an Image Dictionary](lib/ISO_32000/Table_89-Additional_Entries_Specific_to_an_Image_Dictionary.rakumod) |
| /DecodeParms | [Table 5 – Entries common to all stream dictionaries](lib/ISO_32000/Table_5-Entries_common_to_all_stream_dictionaries.rakumod) |
| /Default | [Table 134 – Entries in a type 5 halftone dictionary](lib/ISO_32000/Table_134-Entries_in_a_type_5_halftone_dictionary.rakumod) |
| /DefaultForPrinting | [Table 91 – Entries in an Alternate Image Dictionary](lib/ISO_32000/Table_91-Entries_in_an_Alternate_Image_Dictionary.rakumod) |
| /Desc | [Table 44 – Entries in a file specification dictionary](lib/ISO_32000/Table_44-Entries_in_a_file_specification_dictionary.rakumod) [Table 348 – PrintField attributes](lib/ISO_32000/Table_348-PrintField_attributes.rakumod) |
| /DescendantFonts | [Table 121 – Entries in a Type 0 font dictionary](lib/ISO_32000/Table_121-Entries_in_a_Type_0_font_dictionary.rakumod) |
| /Descent | [Table 122 – Entries common to all font descriptors](lib/ISO_32000/Table_122-Entries_common_to_all_font_descriptors.rakumod) |
| /Dest | [Table 153 – Entries in an outline item dictionary](lib/ISO_32000/Table_153-Entries_in_an_outline_item_dictionary.rakumod) [Table 173 – Additional entries specific to a link annotation](lib/ISO_32000/Table_173-Additional_entries_specific_to_a_link_annotation.rakumod) |
| /DestOutputProfile | [Table 365 – Entries in an output intent dictionary](lib/ISO_32000/Table_365-Entries_in_an_output_intent_dictionary.rakumod) |
| /Dests | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) [Table 31 – Entries in the name dictionary](lib/ISO_32000/Table_31-Entries_in_the_name_dictionary.rakumod) |
| /DevDepGS\_BG | [Table 259 – Entries in a legal attestation dictionary](lib/ISO_32000/Table_259-Entries_in_a_legal_attestation_dictionary.rakumod) |
| /DevDepGS\_FL | [Table 259 – Entries in a legal attestation dictionary](lib/ISO_32000/Table_259-Entries_in_a_legal_attestation_dictionary.rakumod) |
| /DevDepGS\_HT | [Table 259 – Entries in a legal attestation dictionary](lib/ISO_32000/Table_259-Entries_in_a_legal_attestation_dictionary.rakumod) |
| /DevDepGS\_OP | [Table 259 – Entries in a legal attestation dictionary](lib/ISO_32000/Table_259-Entries_in_a_legal_attestation_dictionary.rakumod) |
| /DevDepGS\_TR | [Table 259 – Entries in a legal attestation dictionary](lib/ISO_32000/Table_259-Entries_in_a_legal_attestation_dictionary.rakumod) |
| /DevDepGS\_UCR | [Table 259 – Entries in a legal attestation dictionary](lib/ISO_32000/Table_259-Entries_in_a_legal_attestation_dictionary.rakumod) |
| /DeviceColorant | [Table 364 – Entries in a separation dictionary](lib/ISO_32000/Table_364-Entries_in_a_separation_dictionary.rakumod) |
| /Di | [Table 162 – Entries in a transition dictionary](lib/ISO_32000/Table_162-Entries_in_a_transition_dictionary.rakumod) |
| /Differences | [Table 114 – Entries in an encoding dictionary](lib/ISO_32000/Table_114-Entries_in_an_encoding_dictionary.rakumod) [Table 243 – Entries in the FDF dictionary](lib/ISO_32000/Table_243-Entries_in_the_FDF_dictionary.rakumod) |
| /DigestMethod | [Table 234 – Entries in a signature field seed value dictionary](lib/ISO_32000/Table_234-Entries_in_a_signature_field_seed_value_dictionary.rakumod) [Table 253 – Entries in a signature reference dictionary](lib/ISO_32000/Table_253-Entries_in_a_signature_reference_dictionary.rakumod) |
| /Direction | [Table 150 – Entries in a viewer preferences dictionary](lib/ISO_32000/Table_150-Entries_in_a_viewer_preferences_dictionary.rakumod) |
| /DisplayDocTitle | [Table 150 – Entries in a viewer preferences dictionary](lib/ISO_32000/Table_150-Entries_in_a_viewer_preferences_dictionary.rakumod) |
| /Dm | [Table 162 – Entries in a transition dictionary](lib/ISO_32000/Table_162-Entries_in_a_transition_dictionary.rakumod) |
| /Doc | [Table 245 – Entries in the JavaScript dictionary](lib/ISO_32000/Table_245-Entries_in_the_JavaScript_dictionary.rakumod) |
| /DocMDP | [Table 258 – Entries in a permissions dictionary](lib/ISO_32000/Table_258-Entries_in_a_permissions_dictionary.rakumod) |
| /Document | [Table 255 – Entries in the UR transform parameters dictionary](lib/ISO_32000/Table_255-Entries_in_the_UR_transform_parameters_dictionary.rakumod) |
| /Domain | [Table 38 – Entries common to all function dictionaries](lib/ISO_32000/Table_38-Entries_common_to_all_function_dictionaries.rakumod) [Table 79 – Additional Entries Specific to a Type 1 Shading Dictionary](lib/ISO_32000/Table_79-Additional_Entries_Specific_to_a_Type_1_Shading_Dictionary.rakumod) [Table 80 – Additional Entries Specific to a Type 2 Shading Dictionary](lib/ISO_32000/Table_80-Additional_Entries_Specific_to_a_Type_2_Shading_Dictionary.rakumod) [Table 81 – Additional Entries Specific to a Type 3 Shading Dictionary](lib/ISO_32000/Table_81-Additional_Entries_Specific_to_a_Type_3_Shading_Dictionary.rakumod) |
| /DotGain | [Table 73 – Entries in a DeviceN Mixing Hints Dictionary](lib/ISO_32000/Table_73-Entries_in_a_DeviceN_Mixing_Hints_Dictionary.rakumod) |
| /Duplex | [Table 150 – Entries in a viewer preferences dictionary](lib/ISO_32000/Table_150-Entries_in_a_viewer_preferences_dictionary.rakumod) |
| /Dur | [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) [Table 163 – Entries in a navigation node dictionary](lib/ISO_32000/Table_163-Entries_in_a_navigation_node_dictionary.rakumod) |
| /Duration | [Table 296 – Entries in a movie activation dictionary](lib/ISO_32000/Table_296-Entries_in_a_movie_activation_dictionary.rakumod) |
| /E | [Table F.1 – Entries in the linearization parameter dictionary](lib/ISO_32000/Table_F1-Entries_in_the_linearization_parameter_dictionary.rakumod) [Table 157 – Entries in a collection field dictionary](lib/ISO_32000/Table_157-Entries_in_a_collection_field_dictionary.rakumod) [Table 194 – Entries in an annotation’s additional-actions dictionary](lib/ISO_32000/Table_194-Entries_in_an_annotations_additional-actions_dictionary.rakumod) [Table 278 – Entries in a media clip section MH/BE dictionary](lib/ISO_32000/Table_278-Entries_in_a_media_clip_section_MH-BE_dictionary.rakumod) [Table 294 – Additional entries specific to a sound object](lib/ISO_32000/Table_294-Additional_entries_specific_to_a_sound_object.rakumod) [Table 323 – Entries in a structure element dictionary](lib/ISO_32000/Table_323-Entries_in_a_structure_element_dictionary.rakumod) [Table 355 – Entries in a source information dictionary](lib/ISO_32000/Table_355-Entries_in_a_source_information_dictionary.rakumod) |
| /EA | [Table 306 – Entries in a 3D background dictionary](lib/ISO_32000/Table_306-Entries_in_a_ThreeD_background_dictionary.rakumod) |
| /EF | [Table 44 – Entries in a file specification dictionary](lib/ISO_32000/Table_44-Entries_in_a_file_specification_dictionary.rakumod) [Table 255 – Entries in the UR transform parameters dictionary](lib/ISO_32000/Table_255-Entries_in_the_UR_transform_parameters_dictionary.rakumod) |
| /EFF | [Table 20 – Entries common to all encryption dictionaries](lib/ISO_32000/Table_20-Entries_common_to_all_encryption_dictionaries.rakumod) |
| /EarlyChange | [Table 8 – Optional parameters for LZWDecode and FlateDecode filters](lib/ISO_32000/Table_8-Optional_parameters_for_LZWDecode_and_FlateDecode_filters.rakumod) |
| /EmbeddedFDFs | [Table 243 – Entries in the FDF dictionary](lib/ISO_32000/Table_243-Entries_in_the_FDF_dictionary.rakumod) |
| /EmbeddedFiles | [Table 31 – Entries in the name dictionary](lib/ISO_32000/Table_31-Entries_in_the_name_dictionary.rakumod) |
| /Encode | [Table 39 – Additional entries specific to a type 0 function dictionary](lib/ISO_32000/Table_39-Additional_entries_specific_to_a_type_0_function_dictionary.rakumod) [Table 41 – Additional entries specific to a type 3 function dictionary](lib/ISO_32000/Table_41-Additional_entries_specific_to_a_type_3_function_dictionary.rakumod) |
| /EncodedByteAlign | [Table 11 – Optional parameters for the CCITTFaxDecode filter](lib/ISO_32000/Table_11-Optional_parameters_for_the_CCITTFaxDecode_filter.rakumod) |
| /Encoding | [Table 111 – Entries in a Type 1 font dictionary](lib/ISO_32000/Table_111-Entries_in_a_Type_1_font_dictionary.rakumod) [Table 112 – Entries in a Type 3 font dictionary](lib/ISO_32000/Table_112-Entries_in_a_Type_3_font_dictionary.rakumod) [Table 121 – Entries in a Type 0 font dictionary]( |
## dist_zef-dwarring-PDF-ISO_32000.md
## Chunk 5 of 10
lib/ISO_32000/Table_121-Entries_in_a_Type_0_font_dictionary.rakumod) [Table 243 – Entries in the FDF dictionary](lib/ISO_32000/Table_243-Entries_in_the_FDF_dictionary.rakumod) |
| /Encrypt | [Table 15 – Entries in the file trailer dictionary](lib/ISO_32000/Table_15-Entries_in_the_file_trailer_dictionary.rakumod) |
| /EncryptMetadata | [Table 21 – Additional encryption dictionary entries for the standard security handler](lib/ISO_32000/Table_21-Additional_encryption_dictionary_entries_for_the_standard_security_handler.rakumod) [Table 27 – Additional crypt filter dictionary entries for public-key security handlers](lib/ISO_32000/Table_27-Additional_crypt_filter_dictionary_entries_for_public-key_security_handlers.rakumod) |
| /EncryptionRevision | [Table 244 – Additional entry in an embedded file stream dictionary for an encrypted FDF file](lib/ISO_32000/Table_244-Additional_entry_in_an_embedded_file_stream_dictionary_for_an_encrypted_FDF_file.rakumod) |
| /EndIndent | [Table 344 – Additional standard layout attributes specific to block-level structure elements](lib/ISO_32000/Table_344-Additional_standard_layout_attributes_specific_to_block-level_structure_elements.rakumod) |
| /EndOfBlock | [Table 11 – Optional parameters for the CCITTFaxDecode filter](lib/ISO_32000/Table_11-Optional_parameters_for_the_CCITTFaxDecode_filter.rakumod) |
| /EndOfLine | [Table 11 – Optional parameters for the CCITTFaxDecode filter](lib/ISO_32000/Table_11-Optional_parameters_for_the_CCITTFaxDecode_filter.rakumod) |
| /Event | [Table 103 – Entries in a Usage Application Dictionary](lib/ISO_32000/Table_103-Entries_in_a_Usage_Application_Dictionary.rakumod) |
| /ExData | [Table 170 – Additional entries specific to markup annotations](lib/ISO_32000/Table_170-Additional_entries_specific_to_markup_annotations.rakumod) |
| /Export | [Table 102 – Entries in an Optional Content Usage Dictionary](lib/ISO_32000/Table_102-Entries_in_an_Optional_Content_Usage_Dictionary.rakumod) |
| /ExtGState | [Table 33 – Entries in a resource dictionary](lib/ISO_32000/Table_33-Entries_in_a_resource_dictionary.rakumod) [Table 76 – Entries in a Type 2 Pattern Dictionary](lib/ISO_32000/Table_76-Entries_in_a_Type_2_Pattern_Dictionary.rakumod) |
| /Extend | [Table 80 – Additional Entries Specific to a Type 2 Shading Dictionary](lib/ISO_32000/Table_80-Additional_Entries_Specific_to_a_Type_2_Shading_Dictionary.rakumod) [Table 81 – Additional Entries Specific to a Type 3 Shading Dictionary](lib/ISO_32000/Table_81-Additional_Entries_Specific_to_a_Type_3_Shading_Dictionary.rakumod) |
| /Extends | [Table 16 – Additional entries specific to an object stream dictionary](lib/ISO_32000/Table_16-Additional_entries_specific_to_an_object_stream_dictionary.rakumod) |
| /ExtensionLevel | [Table 50 – Entries in a developer extensions dictionary](lib/ISO_32000/Table_50-Entries_in_a_developer_extensions_dictionary.rakumod) |
| /Extensions | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) |
| /ExternalOPIdicts | [Table 259 – Entries in a legal attestation dictionary](lib/ISO_32000/Table_259-Entries_in_a_legal_attestation_dictionary.rakumod) |
| /ExternalRefXobjects | [Table 259 – Entries in a legal attestation dictionary](lib/ISO_32000/Table_259-Entries_in_a_legal_attestation_dictionary.rakumod) |
| /ExternalStreams | [Table 259 – Entries in a legal attestation dictionary](lib/ISO_32000/Table_259-Entries_in_a_legal_attestation_dictionary.rakumod) |
| /F | [Table 5 – Entries common to all stream dictionaries](lib/ISO_32000/Table_5-Entries_common_to_all_stream_dictionaries.rakumod) [Table 44 – Entries in a file specification dictionary](lib/ISO_32000/Table_44-Entries_in_a_file_specification_dictionary.rakumod) [Table 97 – Entries in a Reference Dictionary](lib/ISO_32000/Table_97-Entries_in_a_Reference_Dictionary.rakumod) [Table 153 – Entries in an outline item dictionary](lib/ISO_32000/Table_153-Entries_in_an_outline_item_dictionary.rakumod) [Table 160 – Entries in a thread dictionary](lib/ISO_32000/Table_160-Entries_in_a_thread_dictionary.rakumod) [Table 164 – Entries common to all annotation dictionaries](lib/ISO_32000/Table_164-Entries_common_to_all_annotation_dictionaries.rakumod) [Table 196 – Entries in a form field’s additional-actions dictionary](lib/ISO_32000/Table_196-Entries_in_a_form_fields_additional-actions_dictionary.rakumod) [Table 200 – Additional entries specific to a remote go-to action](lib/ISO_32000/Table_200-Additional_entries_specific_to_a_remote_go-to_action.rakumod) [Table 201 – Additional entries specific to an embedded go-to action](lib/ISO_32000/Table_201-Additional_entries_specific_to_an_embedded_go-to_action.rakumod) [Table 203 – Additional entries specific to a launch action](lib/ISO_32000/Table_203-Additional_entries_specific_to_a_launch_action.rakumod) [Table 204 – Entries in a Windows launch parameter dictionary](lib/ISO_32000/Table_204-Entries_in_a_Windows_launch_parameter_dictionary.rakumod) [Table 205 – Additional entries specific to a thread action](lib/ISO_32000/Table_205-Additional_entries_specific_to_a_thread_action.rakumod) [Table 236 – Additional entries specific to a submit-form action](lib/ISO_32000/Table_236-Additional_entries_specific_to_a_submit-form_action.rakumod) [Table 240 – Additional entries specific to an import-data action](lib/ISO_32000/Table_240-Additional_entries_specific_to_an_import-data_action.rakumod) [Table 243 – Entries in the FDF dictionary](lib/ISO_32000/Table_243-Entries_in_the_FDF_dictionary.rakumod) [Table 246 – Entries in an FDF field dictionary](lib/ISO_32000/Table_246-Entries_in_an_FDF_field_dictionary.rakumod) [Table 250 – Entries in an FDF named page reference dictionary](lib/ISO_32000/Table_250-Entries_in_an_FDF_named_page_reference_dictionary.rakumod) [Table 263 – Entries in a number format dictionary](lib/ISO_32000/Table_263-Entries_in_a_number_format_dictionary.rakumod) [Table 280 – Entries in a media play parameters MH/BE dictionary](lib/ISO_32000/Table_280-Entries_in_a_media_play_parameters_MH-BE_dictionary.rakumod) [Table 283 – Entries in a media screen parameters MH/BE dictionary](lib/ISO_32000/Table_283-Entries_in_a_media_screen_parameters_MH-BE_dictionary.rakumod) [Table 287 – Additional entries in a media offset frame dictionary](lib/ISO_32000/Table_287-Additional_entries_in_a_media_offset_frame_dictionary.rakumod) [Table 295 – Entries in a movie dictionary](lib/ISO_32000/Table_295-Entries_in_a_movie_dictionary.rakumod) [Table 305 – Entries in a projection dictionary](lib/ISO_32000/Table_305-Entries_in_a_projection_dictionary.rakumod) [Table 329 – Entries in a user property dictionary](lib/ISO_32000/Table_329-Entries_in_a_user_property_dictionary.rakumod) [Table 357 – Entries in a Web Capture command dictionary](lib/ISO_32000/Table_357-Entries_in_a_Web_Capture_command_dictionary.rakumod) |
| /FB | [Table 247 – Entries in an icon fit dictionary](lib/ISO_32000/Table_247-Entries_in_an_icon_fit_dictionary.rakumod) |
| /FC | [Table 307 – Entries in a render mode dictionary](lib/ISO_32000/Table_307-Entries_in_a_render_mode_dictionary.rakumod) |
| /FD | [Table 124 – Additional font descriptor entries for CIDFonts](lib/ISO_32000/Table_124-Additional_font_descriptor_entries_for_CIDFonts.rakumod) [Table 263 – Entries in a number format dictionary](lib/ISO_32000/Table_263-Entries_in_a_number_format_dictionary.rakumod) |
| /FDF | [Table 242 – Entries in the FDF catalog dictionary](lib/ISO_32000/Table_242-Entries_in_the_FDF_catalog_dictionary.rakumod) |
| /FDecodeParms | [Table 5 – Entries common to all stream dictionaries](lib/ISO_32000/Table_5-Entries_common_to_all_stream_dictionaries.rakumod) |
| /FFilter | [Table 5 – Entries common to all stream dictionaries](lib/ISO_32000/Table_5-Entries_common_to_all_stream_dictionaries.rakumod) |
| /FL | [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) |
| /FOV | [Table 305 – Entries in a projection dictionary](lib/ISO_32000/Table_305-Entries_in_a_projection_dictionary.rakumod) |
| /FS | [Table 44 – Entries in a file specification dictionary](lib/ISO_32000/Table_44-Entries_in_a_file_specification_dictionary.rakumod) [Table 184 – Additional entries specific to a file attachment annotation](lib/ISO_32000/Table_184-Additional_entries_specific_to_a_file_attachment_annotation.rakumod) |
| /FT | [Table 220 – Entries common to all field dictionaries](lib/ISO_32000/Table_220-Entries_common_to_all_field_dictionaries.rakumod) |
| /FWPosition | [Table 296 – Entries in a movie activation dictionary](lib/ISO_32000/Table_296-Entries_in_a_movie_activation_dictionary.rakumod) |
| /FWScale | [Table 296 – Entries in a movie activation dictionary](lib/ISO_32000/Table_296-Entries_in_a_movie_activation_dictionary.rakumod) |
| /Ff | [Table 220 – Entries common to all field dictionaries](lib/ISO_32000/Table_220-Entries_common_to_all_field_dictionaries.rakumod) [Table 234 – Entries in a signature field seed value dictionary](lib/ISO_32000/Table_234-Entries_in_a_signature_field_seed_value_dictionary.rakumod) [Table 235 – Entries in a certificate seed value dictionary](lib/ISO_32000/Table_235-Entries_in_a_certificate_seed_value_dictionary.rakumod) [Table 246 – Entries in an FDF field dictionary](lib/ISO_32000/Table_246-Entries_in_an_FDF_field_dictionary.rakumod) |
| /Fields | [Table 218 – Entries in the interactive form dictionary](lib/ISO_32000/Table_218-Entries_in_the_interactive_form_dictionary.rakumod) [Table 233 – Entries in a signature field lock dictionary](lib/ISO_32000/Table_233-Entries_in_a_signature_field_lock_dictionary.rakumod) [Table 236 – Additional entries specific to a submit-form action](lib/ISO_32000/Table_236-Additional_entries_specific_to_a_submit-form_action.rakumod) [Table 238 – Additional entries specific to a reset-form action](lib/ISO_32000/Table_238-Additional_entries_specific_to_a_reset-form_action.rakumod) [Table 243 – Entries in the FDF dictionary](lib/ISO_32000/Table_243-Entries_in_the_FDF_dictionary.rakumod) [Table 249 – Entries in an FDF template dictionary](lib/ISO_32000/Table_249-Entries_in_an_FDF_template_dictionary.rakumod) [Table 256 – Entries in the FieldMDP transform parameters dictionary](lib/ISO_32000/Table_256-Entries_in_the_FieldMDP_transform_parameters_dictionary.rakumod) |
| /Filter | [Table 5 – Entries common to all stream dictionaries](lib/ISO_32000/Table_5-Entries_common_to_all_stream_dictionaries.rakumod) [Table 20 – Entries common to all encryption dictionaries](lib/ISO_32000/Table_20-Entries_common_to_all_encryption_dictionaries.rakumod) [Table 234 – Entries in a signature field seed value dictionary](lib/ISO_32000/Table_234-Entries_in_a_signature_field_seed_value_dictionary.rakumod) [Table 252 – Entries in a signature dictionary](lib/ISO_32000/Table_252-Entries_in_a_signature_dictionary.rakumod) |
| /First | [Table 16 – Additional entries specific to an object stream dictionary](lib/ISO_32000/Table_16-Additional_entries_specific_to_an_object_stream_dictionary.rakumod) [Table 152 – Entries in the outline dictionary](lib/ISO_32000/Table_152-Entries_in_the_outline_dictionary.rakumod) [Table 153 – Entries in an outline item dictionary](lib/ISO_32000/Table_153-Entries_in_an_outline_item_dictionary.rakumod) |
| /FirstChar | [Table 111 – Entries in a Type 1 font dictionary](lib/ISO_32000/Table_111-Entries_in_a_Type_1_font_dictionary.rakumod) [Table 112 – Entries in a Type 3 font dictionary](lib/ISO_32000/Table_112-Entries_in_a_Type_3_font_dictionary.rakumod) |
| /FitWindow | [Table 150 – Entries in a viewer preferences dictionary](lib/ISO_32000/Table_150-Entries_in_a_viewer_preferences_dictionary.rakumod) |
| /FixedPrint | [Table 190 – Additional entries specific to a watermark annotation](lib/ISO_32000/Table_190-Additional_entries_specific_to_a_watermark_annotation.rakumod) |
| /Flags | [Table 122 – Entries common to all font descriptors](lib/ISO_32000/Table_122-Entries_common_to_all_font_descriptors.rakumod) [Table 236 – Additional entries specific to a submit-form action](lib/ISO_32000/Table_236-Additional_entries_specific_to_a_submit-form_action.rakumod) [Table 238 – Additional entries specific to a reset-form action](lib/ISO_32000/Table_238-Additional_entries_specific_to_a_reset-form_action.rakumod) |
| /Fo | [Table 194 – Entries in an annotation’s additional-actions dictionary](lib/ISO_32000/Table_194-Entries_in_an_annotations_additional-actions_dictionary.rakumod) |
| /Font | [Table 33 – Entries in a resource dictionary](lib/ISO_32000/Table_33-Entries_in_a_resource_dictionary.rakumod) [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) |
| /FontBBox | [Table 112 – Entries in a Type 3 font dictionary](lib/ISO_32000/Table_112-Entries_in_a_Type_3_font_dictionary.rakumod) [Table 122 – Entries common to all font descriptors](lib/ISO_32000/Table_122-Entries_common_to_all_font_descriptors.rakumod) |
| /FontDescriptor | [Table 111 – Entries in a Type 1 font dictionary](lib/ISO_32000/Table_111-Entries_in_a_Type_1_font_dictionary.rakumod) [Table 112 – Entries in a Type 3 font dictionary](lib/ISO_32000/Table_112-Entries_in_a_Type_3_font_dictionary.rakumod) [Table 117 – Entries in a CIDFont dictionary](lib/ISO_32000/Table_117-Entries_in_a_CIDFont_dictionary.rakumod) |
| /FontFamily | [Table 122 – Entries common to all font descriptors](lib/ISO_32000/Table_122-Entries_common_to_all_font_descriptors.rakumod) |
| /FontFauxing | [Table 366 – Additional entries specific to a trap network annotation](lib/ISO_32000/Table_366-Additional_entries_specific_to_a_trap_network_annotation.rakumod) |
| /FontFile | [Table 122 – Entries common to all font descriptors](lib/ISO_32000/Table_122-Entries_common_to_all_font_descriptors.rakumod) [Table 126 – Embedded font organization for various font types](lib/ISO_32000/Table_126-Embedded_font_organization_for_various_font_types.rakumod) |
| /FontFile2 | [Table 122 – Entries common to all font descriptors](lib/ISO_32000/Table_122-Entries_common_to_all_font_descriptors.rakumod) [Table 126 – Embedded font organization for various font types](lib/ISO_32000/Table_126-Embedded_font_organization_for_various_font_types.rakumod) |
| /FontFile3 | [Table 122 – Entries common to all font descriptors](lib/ISO_32000/Table_122-Entries_common_to_all_font_descriptors.rakumod) [Table 126 – Embedded font organization for various font types](lib/ISO_32000/Table_126-Embedded_font_organization_for_various_font_types.rakumod) |
| /FontMatrix | [Table 112 – Entries in a Type 3 font dictionary](lib/ISO_32000/Table_112-Entries_in_a_Type_3_font_dictionary.rakumod) |
| /FontName | [Table 122 – Entries common to all font descriptors](lib/ISO_32000/Table_122-Entries_common_to_all_font_descriptors.rakumod) |
| /FontStretch | [Table 122 – Entries common to all font descriptors](lib/ISO_32000/Table_122-Entries_common_to_all_font_descriptors.rakumod) |
| /FontWeight | [Table 122 – Entries common to all font descriptors](lib/ISO_32000/Table_122-Entries_common_to_all_font_descriptors.rakumod) |
| /Form | [Table 255 – Entries in the UR transform parameters dictionary](lib/ISO_32000/Table_255-Entries_in_the_UR_transform_parameters_dictionary.rakumod) |
| /FormType | [Table 95 – Additional Entries Specific to a Type 1 Form Dictionary](lib/ISO_32000/Table_95-Additional_Entries_Specific_to_a_Type_1_Form_Dictionary.rakumod) |
| /Frequency | [Table 130 – Entries in a type 1 halftone dictionary](lib/ISO_32000/Table_130-Entries_in_a_type_1_halftone_dictionary.rakumod) |
| /Function | [Table 79 – Additional Entries Specific to a Type 1 Shading Dictionary](lib/ISO_32000/Table_79-Additional_Entries_Specific_to_a_Type_1_Shading_Dictionary.rakumod) [Table 80 – Additional Entries Specific to a Type 2 Shading Dictionary](lib/ISO_32000/Table_80-Additional_Entries_Specific_to_a_Type_2_Shading_Dictionary.rakumod) [Table 81 – Additional Entries Specific to a Type 3 Shading Dictionary](lib/ISO_32000/Table_81-Additional_Entries_Specific_to_a_Type_3_Shading_Dictionary.rakumod) [Table 82 – Additional Entries Specific to a Type 4 Shading Dictionary](lib/ISO_32000/Table_82-Additional_Entries_Specific_to_a_Type_4_Shading_Dictionary.rakumod) [Table 83 – Additional Entries Specific to a Type 5 Shading Dictionary](lib/ISO_32000/Table_83-Additional_Entries_Specific_to_a_Type_5_Shading_Dictionary.rakumod) [Table 84 – Additional Entries Specific to a Type 6 Shading Dictionary](lib/ISO_32000/Table_84-Additional_Entries_Specific_to_a_Type_6_Shading_Dictionary.rakumod) |
| /FunctionType | [Table 38 – Entries common to all function dictionaries](lib/ISO_32000/Table_38-Entries_common_to_all_function_dictionaries.rakumod) |
| /Functions | [Table 41 – Additional entries specific to a type 3 function dictionary](lib/ISO_32000/Table_41-Additional_entries_specific_to_a_type_3_function_dictionary.rakumod) |
| /G | [Table 144 – Entries in a soft-mask dictionary](lib/ISO_32000/Table_144-Entries_in_a_soft-mask_dictionary.rakumod) [Table 359 – Entries in a Web Capture command settings dictionary](lib/ISO_32000/Table_359-Entries_in_a_Web_Capture_command_settings_dictionary.rakumod) |
| /Gamma | [Table 63 – Entries in a CalGray Colour Space Dictionary](lib/ISO_32000/Table_63-Entries_in_a_CalGray_Colour_Space_Dictionary.rakumod) [Table 64 – Entries in a CalRGB Colour Space Dictionary](lib/ISO_32000/Table_64-Entries_in_a_CalRGB_Colour_Space_Dictionary.rakumod) |
| /GlyphOrientationVertical | [Table 345 – Standard layout attributes specific to inline-level structure elements](lib/ISO_32000/Table_345-Standard_layout_attributes_specific_to_inline-level_structure_elements.rakumod) |
| /GoToRemoteActions | [Table 259 – Entries in a legal attestation dictionary](lib/ISO_32000/Table_259-Entries_in_a_legal_attestation_dictionary.rakumod) |
| /Group | [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) [Table 95 – Additional Entries Specific to a Type 1 Form Dictionary](lib/ISO_32000/Table_95-Additional_Entries_Specific_to_a_Type_1_Form_Dictionary.rakumod) |
| /H | [Table F.1 – Entries in the linearization parameter dictionary](lib/ISO_32000/Table_F1-Entries_in_the_linearization_parameter_dictionary.rakumod) [Table 173 – Additional entries specific to a link annotation](lib/ISO_32000/Table_173-Additional_entries_specific_to_a_link_annotation.rakumod) [Table 188 – Additional entries specific to a widget annotation](lib/ISO_32000/Table_188-Additional_entries_specific_to_a_widget_annotation.rakumod) [Table 191 – Entries in a fixed print dictionary](lib/ISO_32000/Table_191-Entries_in_a_fixed_print_dictionary.rakumod) [Table 210 – Additional entries specific to a hide action](lib/ISO_32000/Table_210-Additional_entries_specific_to_a_hide_action.rakumod) [Table 292 – Entries in a software identifier dictionary](lib/ISO_32000/Table_292-Entries_in_a_software_identifier_dictionary.rakumod) [Table 329 – Entries in a user property dictionary](lib/ISO_32000/Table_329-Entries_in_a_user_property_dictionary.rakumod) [Table 357 – Entries in a Web Capture command dictionary](lib/ISO_32000/Table_357-Entries_in_a_Web_Capture_command_dictionary.rakumod) |
| /HI | [Table 292 – Entries in a software identifier dictionary](lib/ISO_32000/Table_292-Entries_in_a_software_identifier_dictionary.rakumod) |
| /HT | [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) |
| /HalftoneName | [Table 130 – Entries in a type 1 halftone dictionary](lib/ISO_32000/Table_130-Entries_in_a_type_1_halftone_dictionary.rakumod) [Table 131 – Additional entries specific to a type 6 halftone dictionary](lib/ISO_32000/Table_131-Additional_entries_specific_to_a_type_6_halftone_dictionary.rakumod) [Table 132 – Additional entries specific to a type 10 halftone dictionary](lib/ISO_32000/Table_132-Additional_entries_specific_to_a_type_10_halftone_dictionary.rakumod) [Table 133 – Additional entries specific to a type 16 halftone dictionary](lib/ISO_32000/Table_133-Additional_entries_specific_to_a_type_16_halftone_dictionary.rakumod) [Table 134 – Entries in a type 5 halftone dictionary](lib/ISO_32000/Table_134-Entries_in_a_type_5_halftone_dictionary.rakumod) |
| /HalftoneType | [Table 130 – Entries in a type 1 halftone dictionary](lib/ISO_32000/Table_130-Entries_in_a_type_1_halftone_dictionary.rakumod) [Table 131 – Additional entries specific to a type 6 halftone dictionary](lib/ISO_32000/Table_131-Additional_entries_specific_to_a_type_6_halftone_dictionary.rakumod) [Table 132 – Additional entries specific to a type 10 halftone dictionary](lib/ISO_32000/Table_132-Additional_entries_specific_to_a_type_10_halftone_dictionary.rakumod) [Table 133 – Additional entries specific to a type 16 halftone dictionary](lib/ISO_32000/Table_133-Additional_entries_specific_to_a_type_16_halftone_dictionary.rakumod) [Table 134 – Entries in a type 5 halftone dictionary](lib/ISO_32000/Table_134-Entries_in_a_type_5_halftone_dictionary.rakumod) |
| /Headers | [Table 349 – Standard table attributes](lib/ISO_32000/Table_349-Standard_table_attributes.rakumod) |
| /Height | [Table 89 – Additional Entries Specific to an Image Dictionary](lib/ISO_32000/Table_89-Additional_Entries_Specific_to_an_Image_Dictionary.rakumod) [Table 131 – Additional entries specific to a type 6 halftone dictionary](lib/ISO_32000/Table_131-Additional_entries_specific_to_a_type_6_halftone_dictionary.rakumod) [Table 133 – Additional entries specific to a type 16 halftone dictionary](lib/ISO_32000/Table_133-Additional_entries_specific_to_a_type_16_halftone_dictionary.rakumod) [Table 344 – Additional standard layout attributes specific to block-level structure elements](lib/ISO_32000/Table_344-Additional_standard_layout_attributes_specific_to_block-level_structure_elements.rakumod) |
| /Height2 | [Table 133 – Additional entries specific to a type 16 halftone dictionary](lib/ISO_32000/Table_133-Additional_entries_specific_to_a_type_16_halftone_dictionary.rakumod) |
| /HideAnnotationActions | [Table 259 – Entries in a legal attestation dictionary](lib/ISO_32000/Table_259-Entries_in_a_legal_attestation_dictionary.rakumod) |
| /HideMenubar | [Table 150 – Entries in a viewer preferences dictionary](lib/ISO_32000/Table_150-Entries_in_a_viewer_preferences_dictionary.rakumod) |
| /HideToolbar | [Table 150 – Entries in a viewer preferences dictionary](lib/ISO_32000/Table_150-Entries_in_a_viewer_preferences_dictionary.rakumod) |
| /HideWindowUI | [Table 150 – Entries in a viewer preferences dictionary](lib/ISO_32000/Table_150-Entries_in_a_viewer_preferences_dictionary.rakumod) |
| /I | [Table 147 – Additional entries specific to a transparency group attributes dictionary](lib/ISO_32000/Table_147-Additional_entries_specific_to_a_transparency_group_attributes_dictionary.rakumod) [Table 160 – Entries in a thread dictionary](lib/ISO_32000/Table_160-Entries_in_a_thread_dictionary.rakumod) [Table 167 – Entries in a border effect dictionary](lib/ISO_32000/Table_167-Entries_in_a_border_effect_dictionary.rakumod) [Table 189 – Entries in an appearance characteristics dictionary](lib/ISO_32000/Table_189-Entries_in_an_appearance_characteristics_dictionary.rakumod) [Table 231 – Additional entries specific to a choice field](lib/ISO_32000/Table_231-Additional_entries_specific_to_a_choice_field.rakumod) |
| /IC | [Table 175 – Additional entries specific to a line annotation](lib/ISO_32000/Table_175-Additional_entries_specific_to_a_line_annotation.rakumod) [Table 177 – Additional entries specific to a square or circle annotation](lib/ISO_32000/Table_177-Additional_entries_specific_to_a_square_or_circle_annotation.rakumod) [Table 178 – Additional entries specific to a polygon or polyline annotation](lib/ISO_32000/Table_178-Additional_entries_specific_to_a_polygon_or_polyline_annotation.rakumod) [Table 192 – Additional entries specific to a redaction annotation](lib/ISO_32000/Table_192-Additional_entries_specific_to_a_redaction_annotation.rakumod) [Table 311 – Entries in a 3D cross section dictionary](lib/ISO_32000/Table_311-Entries_in_a_ThreeD_cross_section_dictionary.rakumod) |
| /ID | [Table 15 – Entries in the file trailer dictionary](lib/ISO_32000/Table_15-Entries_in_the_file_trailer_dictionary.rakumod) [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) [Table 44 – Entries in a file specification dictionary](lib/ISO_32000/Table_44-Entries_in_a_file_specification_dictionary.rakumod) [Table 89 – Additional Entries Specific to an Image Dictionary](lib/ISO_32000/Table_89-Additional_Entries_Specific_to_an_Image_Dictionary.rakumod) [Table 97 – Entries in a Reference Dictionary](lib/ISO_32000/Table_97-Entries_in_a_Reference_Dictionary.rakumod) [Table 243 – Entries in the FDF dictionary](lib/ISO_32000/Table_243-Entries_in_the_FDF_dictionary.rakumod) [Table 323 – Entries in a structure element dictionary](lib/ISO_32000/Table_323-Entries_in_a_structure_element_dictionary.rakumod) [Table 352 – Entries common to all Web Capture content sets](lib/ISO_32000/Table_352-Entries_common_to_all_Web_Capture_content_sets.rakumod) |
| /IDS | [Table 31 – Entries in the name dictionary](lib/ISO_32000/Table_31-Entries_in_the_name_dictionary.rakumod) |
| /IDTree | [Table 322 – Entries in the structure tree root](lib/ISO_32000/Table_322-Entries_in_the_structure_tree_root.rakumod) |
| /IF | [Table 189 – Entries in an appearance characteristics dictionary](lib/ISO_32000/Table_189-Entries_in_an_appearance_characteristics_dictionary.rakumod) [Table 246 – Entries in an FDF field dictionary](lib/ISO_32000/Table_246-Entries_in_an_FDF_field_dictionary.rakumod) |
| /IN | [Table 304 – Entries in a 3D view dictionary](lib/ISO_32000/Table_304-Entries_in_a_ThreeD_view_dictionary.rakumod) |
| /IRT | [Table 170 – Additional entries specific to markup annotations](lib/ISO_320 |
## dist_zef-dwarring-PDF-ISO_32000.md
## Chunk 6 of 10
00/Table_170-Additional_entries_specific_to_markup_annotations.rakumod) |
| /IT | [Table 170 – Additional entries specific to markup annotations](lib/ISO_32000/Table_170-Additional_entries_specific_to_markup_annotations.rakumod) [Table 174 – Additional entries specific to a free text annotation](lib/ISO_32000/Table_174-Additional_entries_specific_to_a_free_text_annotation.rakumod) [Table 175 – Additional entries specific to a line annotation](lib/ISO_32000/Table_175-Additional_entries_specific_to_a_line_annotation.rakumod) [Table 178 – Additional entries specific to a polygon or polyline annotation](lib/ISO_32000/Table_178-Additional_entries_specific_to_a_polygon_or_polyline_annotation.rakumod) |
| /IV | [Table 311 – Entries in a 3D cross section dictionary](lib/ISO_32000/Table_311-Entries_in_a_ThreeD_cross_section_dictionary.rakumod) |
| /IX | [Table 189 – Entries in an appearance characteristics dictionary](lib/ISO_32000/Table_189-Entries_in_an_appearance_characteristics_dictionary.rakumod) |
| /Image | [Table 91 – Entries in an Alternate Image Dictionary](lib/ISO_32000/Table_91-Entries_in_an_Alternate_Image_Dictionary.rakumod) |
| /ImageMask | [Table 89 – Additional Entries Specific to an Image Dictionary](lib/ISO_32000/Table_89-Additional_Entries_Specific_to_an_Image_Dictionary.rakumod) |
| /Index | [Table 17 – Additional entries specific to a cross-reference stream dictionary](lib/ISO_32000/Table_17-Additional_entries_specific_to_a_cross-reference_stream_dictionary.rakumod) |
| /Info | [Table 15 – Entries in the file trailer dictionary](lib/ISO_32000/Table_15-Entries_in_the_file_trailer_dictionary.rakumod) [Table 248 – Entries in an FDF page dictionary](lib/ISO_32000/Table_248-Entries_in_an_FDF_page_dictionary.rakumod) [Table 365 – Entries in an output intent dictionary](lib/ISO_32000/Table_365-Entries_in_an_output_intent_dictionary.rakumod) |
| /InkList | [Table 182 – Additional entries specific to an ink annotation](lib/ISO_32000/Table_182-Additional_entries_specific_to_an_ink_annotation.rakumod) |
| /InlineAlign | [Table 344 – Additional standard layout attributes specific to block-level structure elements](lib/ISO_32000/Table_344-Additional_standard_layout_attributes_specific_to_block-level_structure_elements.rakumod) |
| /Intent | [Table 89 – Additional Entries Specific to an Image Dictionary](lib/ISO_32000/Table_89-Additional_Entries_Specific_to_an_Image_Dictionary.rakumod) [Table 98 – Entries in an Optional Content Group Dictionary](lib/ISO_32000/Table_98-Entries_in_an_Optional_Content_Group_Dictionary.rakumod) [Table 101 – Entries in an Optional Content Configuration Dictionary](lib/ISO_32000/Table_101-Entries_in_an_Optional_Content_Configuration_Dictionary.rakumod) |
| /Interpolate | [Table 89 – Additional Entries Specific to an Image Dictionary](lib/ISO_32000/Table_89-Additional_Entries_Specific_to_an_Image_Dictionary.rakumod) |
| /IsMap | [Table 206 – Additional entries specific to a URI action](lib/ISO_32000/Table_206-Additional_entries_specific_to_a_URI_action.rakumod) |
| /Issuer | [Table 235 – Entries in a certificate seed value dictionary](lib/ISO_32000/Table_235-Entries_in_a_certificate_seed_value_dictionary.rakumod) |
| /ItalicAngle | [Table 122 – Entries common to all font descriptors](lib/ISO_32000/Table_122-Entries_common_to_all_font_descriptors.rakumod) |
| /JBIG2Globals | [Table 12 – Optional parameter for the JBIG2Decode filter](lib/ISO_32000/Table_12-Optional_parameter_for_the_JBIG2Decode_filter.rakumod) |
| /JS | [Table 214 – Additional entries specific to a rendition action](lib/ISO_32000/Table_214-Additional_entries_specific_to_a_rendition_action.rakumod) [Table 217 – Additional entries specific to a JavaScript action](lib/ISO_32000/Table_217-Additional_entries_specific_to_a_JavaScript_action.rakumod) |
| /JavaScript | [Table 31 – Entries in the name dictionary](lib/ISO_32000/Table_31-Entries_in_the_name_dictionary.rakumod) [Table 243 – Entries in the FDF dictionary](lib/ISO_32000/Table_243-Entries_in_the_FDF_dictionary.rakumod) |
| /JavaScriptActions | [Table 259 – Entries in a legal attestation dictionary](lib/ISO_32000/Table_259-Entries_in_a_legal_attestation_dictionary.rakumod) |
| /K | [Table 11 – Optional parameters for the CCITTFaxDecode filter](lib/ISO_32000/Table_11-Optional_parameters_for_the_CCITTFaxDecode_filter.rakumod) [Table 147 – Additional entries specific to a transparency group attributes dictionary](lib/ISO_32000/Table_147-Additional_entries_specific_to_a_transparency_group_attributes_dictionary.rakumod) [Table 196 – Entries in a form field’s additional-actions dictionary](lib/ISO_32000/Table_196-Entries_in_a_form_fields_additional-actions_dictionary.rakumod) [Table 322 – Entries in the structure tree root](lib/ISO_32000/Table_322-Entries_in_the_structure_tree_root.rakumod) [Table 323 – Entries in a structure element dictionary](lib/ISO_32000/Table_323-Entries_in_a_structure_element_dictionary.rakumod) |
| /KeyUsage | [Table 235 – Entries in a certificate seed value dictionary](lib/ISO_32000/Table_235-Entries_in_a_certificate_seed_value_dictionary.rakumod) |
| /Keywords | [Table 317 – Entries in the document information dictionary](lib/ISO_32000/Table_317-Entries_in_the_document_information_dictionary.rakumod) |
| /Kids | [Table 29 – Required entries in a page tree node](lib/ISO_32000/Table_29-Required_entries_in_a_page_tree_node.rakumod) [Table 36 – Entries in a name tree node dictionary](lib/ISO_32000/Table_36-Entries_in_a_name_tree_node_dictionary.rakumod) [Table 37 – Entries in a number tree node dictionary](lib/ISO_32000/Table_37-Entries_in_a_number_tree_node_dictionary.rakumod) [Table 220 – Entries common to all field dictionaries](lib/ISO_32000/Table_220-Entries_common_to_all_field_dictionaries.rakumod) [Table 246 – Entries in an FDF field dictionary](lib/ISO_32000/Table_246-Entries_in_an_FDF_field_dictionary.rakumod) |
| /L | [Table F.1 – Entries in the linearization parameter dictionary](lib/ISO_32000/Table_F1-Entries_in_the_linearization_parameter_dictionary.rakumod) [Table 175 – Additional entries specific to a line annotation](lib/ISO_32000/Table_175-Additional_entries_specific_to_a_line_annotation.rakumod) [Table 268 – Entries in a media criteria dictionary](lib/ISO_32000/Table_268-Entries_in_a_media_criteria_dictionary.rakumod) [Table 292 – Entries in a software identifier dictionary](lib/ISO_32000/Table_292-Entries_in_a_software_identifier_dictionary.rakumod) [Table 357 – Entries in a Web Capture command dictionary](lib/ISO_32000/Table_357-Entries_in_a_Web_Capture_command_dictionary.rakumod) |
| /LC | [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) |
| /LE | [Table 174 – Additional entries specific to a free text annotation](lib/ISO_32000/Table_174-Additional_entries_specific_to_a_free_text_annotation.rakumod) [Table 175 – Additional entries specific to a line annotation](lib/ISO_32000/Table_175-Additional_entries_specific_to_a_line_annotation.rakumod) [Table 178 – Additional entries specific to a polygon or polyline annotation](lib/ISO_32000/Table_178-Additional_entries_specific_to_a_polygon_or_polyline_annotation.rakumod) |
| /LI | [Table 292 – Entries in a software identifier dictionary](lib/ISO_32000/Table_292-Entries_in_a_software_identifier_dictionary.rakumod) |
| /LJ | [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) |
| /LL | [Table 175 – Additional entries specific to a line annotation](lib/ISO_32000/Table_175-Additional_entries_specific_to_a_line_annotation.rakumod) |
| /LLE | [Table 175 – Additional entries specific to a line annotation](lib/ISO_32000/Table_175-Additional_entries_specific_to_a_line_annotation.rakumod) |
| /LLO | [Table 175 – Additional entries specific to a line annotation](lib/ISO_32000/Table_175-Additional_entries_specific_to_a_line_annotation.rakumod) |
| /LS | [Table 304 – Entries in a 3D view dictionary](lib/ISO_32000/Table_304-Entries_in_a_ThreeD_view_dictionary.rakumod) |
| /LW | [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) |
| /Lang | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) [Table 124 – Additional font descriptor entries for CIDFonts](lib/ISO_32000/Table_124-Additional_font_descriptor_entries_for_CIDFonts.rakumod) [Table 323 – Entries in a structure element dictionary](lib/ISO_32000/Table_323-Entries_in_a_structure_element_dictionary.rakumod) |
| /Language | [Table 102 – Entries in an Optional Content Usage Dictionary](lib/ISO_32000/Table_102-Entries_in_an_Optional_Content_Usage_Dictionary.rakumod) |
| /Last | [Table 152 – Entries in the outline dictionary](lib/ISO_32000/Table_152-Entries_in_the_outline_dictionary.rakumod) [Table 153 – Entries in an outline item dictionary](lib/ISO_32000/Table_153-Entries_in_an_outline_item_dictionary.rakumod) |
| /LastChar | [Table 111 – Entries in a Type 1 font dictionary](lib/ISO_32000/Table_111-Entries_in_a_Type_1_font_dictionary.rakumod) [Table 112 – Entries in a Type 3 font dictionary](lib/ISO_32000/Table_112-Entries_in_a_Type_3_font_dictionary.rakumod) |
| /LastModified | [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) [Table 95 – Additional Entries Specific to a Type 1 Form Dictionary](lib/ISO_32000/Table_95-Additional_Entries_Specific_to_a_Type_1_Form_Dictionary.rakumod) [Table 319 – Entries in an data dictionary](lib/ISO_32000/Table_319-Entries_in_an_data_dictionary.rakumod) [Table 366 – Additional entries specific to a trap network annotation](lib/ISO_32000/Table_366-Additional_entries_specific_to_a_trap_network_annotation.rakumod) |
| /LaunchActions | [Table 259 – Entries in a legal attestation dictionary](lib/ISO_32000/Table_259-Entries_in_a_legal_attestation_dictionary.rakumod) |
| /Leading | [Table 122 – Entries common to all font descriptors](lib/ISO_32000/Table_122-Entries_common_to_all_font_descriptors.rakumod) |
| /Legal | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) |
| /LegalAttestation | [Table 234 – Entries in a signature field seed value dictionary](lib/ISO_32000/Table_234-Entries_in_a_signature_field_seed_value_dictionary.rakumod) |
| /Length | [Table 5 – Entries common to all stream dictionaries](lib/ISO_32000/Table_5-Entries_common_to_all_stream_dictionaries.rakumod) [Table 20 – Entries common to all encryption dictionaries](lib/ISO_32000/Table_20-Entries_common_to_all_encryption_dictionaries.rakumod) [Table 25 – Entries common to all crypt filter dictionaries](lib/ISO_32000/Table_25-Entries_common_to_all_crypt_filter_dictionaries.rakumod) |
| /Length1 | [Table 127 – Additional entries in an embedded font stream dictionary](lib/ISO_32000/Table_127-Additional_entries_in_an_embedded_font_stream_dictionary.rakumod) |
| /Length2 | [Table 127 – Additional entries in an embedded font stream dictionary](lib/ISO_32000/Table_127-Additional_entries_in_an_embedded_font_stream_dictionary.rakumod) |
| /Length3 | [Table 127 – Additional entries in an embedded font stream dictionary](lib/ISO_32000/Table_127-Additional_entries_in_an_embedded_font_stream_dictionary.rakumod) |
| /Level1 | [Table 88 – Additional Entries Specific to a PostScript XObject Dictionary](lib/ISO_32000/Table_88-Additional_Entries_Specific_to_a_PostScript_XObject_Dictionary.rakumod) |
| /Limits | [Table 36 – Entries in a name tree node dictionary](lib/ISO_32000/Table_36-Entries_in_a_name_tree_node_dictionary.rakumod) [Table 37 – Entries in a number tree node dictionary](lib/ISO_32000/Table_37-Entries_in_a_number_tree_node_dictionary.rakumod) |
| /LineHeight | [Table 345 – Standard layout attributes specific to inline-level structure elements](lib/ISO_32000/Table_345-Standard_layout_attributes_specific_to_inline-level_structure_elements.rakumod) |
| /Linearized | [Table F.1 – Entries in the linearization parameter dictionary](lib/ISO_32000/Table_F1-Entries_in_the_linearization_parameter_dictionary.rakumod) |
| /ListMode | [Table 101 – Entries in an Optional Content Configuration Dictionary](lib/ISO_32000/Table_101-Entries_in_an_Optional_Content_Configuration_Dictionary.rakumod) |
| /ListNumbering | [Table 347 – Standard list attribute](lib/ISO_32000/Table_347-Standard_list_attribute.rakumod) |
| /Location | [Table 252 – Entries in a signature dictionary](lib/ISO_32000/Table_252-Entries_in_a_signature_dictionary.rakumod) |
| /Lock | [Table 232 – Additional entries specific to a signature field](lib/ISO_32000/Table_232-Additional_entries_specific_to_a_signature_field.rakumod) |
| /Locked | [Table 101 – Entries in an Optional Content Configuration Dictionary](lib/ISO_32000/Table_101-Entries_in_an_Optional_Content_Configuration_Dictionary.rakumod) |
| /M | [Table 162 – Entries in a transition dictionary](lib/ISO_32000/Table_162-Entries_in_a_transition_dictionary.rakumod) [Table 164 – Entries common to all annotation dictionaries](lib/ISO_32000/Table_164-Entries_common_to_all_annotation_dictionaries.rakumod) [Table 252 – Entries in a signature dictionary](lib/ISO_32000/Table_252-Entries_in_a_signature_dictionary.rakumod) [Table 269 – Entries in a minimum bit depth dictionary](lib/ISO_32000/Table_269-Entries_in_a_minimum_bit_depth_dictionary.rakumod) [Table 270 – Entries in a minimum screen size dictionary](lib/ISO_32000/Table_270-Entries_in_a_minimum_screen_size_dictionary.rakumod) [Table 283 – Entries in a media screen parameters MH/BE dictionary](lib/ISO_32000/Table_283-Entries_in_a_media_screen_parameters_MH-BE_dictionary.rakumod) [Table 288 – Additional entries in a media offset marker dictionary](lib/ISO_32000/Table_288-Additional_entries_in_a_media_offset_marker_dictionary.rakumod) [Table 312 – Entries in a 3D node dictionary](lib/ISO_32000/Table_312-Entries_in_a_ThreeD_node_dictionary.rakumod) |
| /MCID | [Table 324 – Entries in a marked-content reference dictionary](lib/ISO_32000/Table_324-Entries_in_a_marked-content_reference_dictionary.rakumod) |
| /MD5 | [Table 313 – Entries in an external data dictionary used to markup 3D annotations](lib/ISO_32000/Table_313-Entries_in_an_external_data_dictionary_used_to_markup_ThreeD_annotations.rakumod) |
| /MDP | [Table 234 – Entries in a signature field seed value dictionary](lib/ISO_32000/Table_234-Entries_in_a_signature_field_seed_value_dictionary.rakumod) |
| /MH | [Table 266 – Entries common to all rendition dictionaries](lib/ISO_32000/Table_266-Entries_common_to_all_rendition_dictionaries.rakumod) [Table 274 – Additional entries in a media clip data dictionary](lib/ISO_32000/Table_274-Additional_entries_in_a_media_clip_data_dictionary.rakumod) [Table 277 – Additional entries in a media clip section dictionary](lib/ISO_32000/Table_277-Additional_entries_in_a_media_clip_section_dictionary.rakumod) [Table 279 – Entries in a media play parameters dictionary](lib/ISO_32000/Table_279-Entries_in_a_media_play_parameters_dictionary.rakumod) [Table 282 – Entries in a media screen parameters dictionary](lib/ISO_32000/Table_282-Entries_in_a_media_screen_parameters_dictionary.rakumod) [Table 291 – Entries in a media player info dictionary](lib/ISO_32000/Table_291-Entries_in_a_media_player_info_dictionary.rakumod) |
| /MK | [Table 187 – Additional entries specific to a screen annotation](lib/ISO_32000/Table_187-Additional_entries_specific_to_a_screen_annotation.rakumod) [Table 188 – Additional entries specific to a widget annotation](lib/ISO_32000/Table_188-Additional_entries_specific_to_a_widget_annotation.rakumod) |
| /ML | [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) |
| /MN | [Table 362 – Additional entries specific to a printer’s mark annotation](lib/ISO_32000/Table_362-Additional_entries_specific_to_a_printers_mark_annotation.rakumod) |
| /MS | [Table 304 – Entries in a 3D view dictionary](lib/ISO_32000/Table_304-Entries_in_a_ThreeD_view_dictionary.rakumod) |
| /MU | [Table 290 – Entries in a media players dictionary](lib/ISO_32000/Table_290-Entries_in_a_media_players_dictionary.rakumod) |
| /Mac | [Table 44 – Entries in a file specification dictionary](lib/ISO_32000/Table_44-Entries_in_a_file_specification_dictionary.rakumod) [Table 46 – Entries in an embedded file parameter dictionary](lib/ISO_32000/Table_46-Entries_in_an_embedded_file_parameter_dictionary.rakumod) [Table 203 – Additional entries specific to a launch action](lib/ISO_32000/Table_203-Additional_entries_specific_to_a_launch_action.rakumod) |
| /MarkInfo | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) |
| /MarkStyle | [Table 363 – Additional entries specific to a printer’s mark form dictionary](lib/ISO_32000/Table_363-Additional_entries_specific_to_a_printers_mark_form_dictionary.rakumod) |
| /Marked | [Table 321 – Entries in the mark information dictionary](lib/ISO_32000/Table_321-Entries_in_the_mark_information_dictionary.rakumod) |
| /Mask | [Table 89 – Additional Entries Specific to an Image Dictionary](lib/ISO_32000/Table_89-Additional_Entries_Specific_to_an_Image_Dictionary.rakumod) |
| /Matrix | [Table 64 – Entries in a CalRGB Colour Space Dictionary](lib/ISO_32000/Table_64-Entries_in_a_CalRGB_Colour_Space_Dictionary.rakumod) [Table 75 – Additional Entries Specific to a Type 1 Pattern Dictionary](lib/ISO_32000/Table_75-Additional_Entries_Specific_to_a_Type_1_Pattern_Dictionary.rakumod) [Table 76 – Entries in a Type 2 Pattern Dictionary](lib/ISO_32000/Table_76-Entries_in_a_Type_2_Pattern_Dictionary.rakumod) [Table 79 – Additional Entries Specific to a Type 1 Shading Dictionary](lib/ISO_32000/Table_79-Additional_Entries_Specific_to_a_Type_1_Shading_Dictionary.rakumod) [Table 95 – Additional Entries Specific to a Type 1 Form Dictionary](lib/ISO_32000/Table_95-Additional_Entries_Specific_to_a_Type_1_Form_Dictionary.rakumod) [Table 191 – Entries in a fixed print dictionary](lib/ISO_32000/Table_191-Entries_in_a_fixed_print_dictionary.rakumod) |
| /Matte | [Table 146 – Additional entry in a soft-mask image dictionary](lib/ISO_32000/Table_146-Additional_entry_in_a_soft-mask_image_dictionary.rakumod) |
| /MaxLen | [Table 229 – Additional entry specific to a text field](lib/ISO_32000/Table_229-Additional_entry_specific_to_a_text_field.rakumod) |
| /MaxWidth | [Table 122 – Entries common to all font descriptors](lib/ISO_32000/Table_122-Entries_common_to_all_font_descriptors.rakumod) |
| /Measure | [Table 175 – Additional entries specific to a line annotation](lib/ISO_32000/Table_175-Additional_entries_specific_to_a_line_annotation.rakumod) [Table 178 – Additional entries specific to a polygon or polyline annotation](lib/ISO_32000/Table_178-Additional_entries_specific_to_a_polygon_or_polyline_annotation.rakumod) [Table 260 – Entries in a viewport dictionary](lib/ISO_32000/Table_260-Entries_in_a_viewport_dictionary.rakumod) |
| /MediaBox | [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) |
| /Metadata | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) [Table 66 – Additional Entries Specific to an ICC Profile Stream Dictionary](lib/ISO_32000/Table_66-Additional_Entries_Specific_to_an_ICC_Profile_Stream_Dictionary.rakumod) [Table 89 – Additional Entries Specific to an Image Dictionary](lib/ISO_32000/Table_89-Additional_Entries_Specific_to_an_Image_Dictionary.rakumod) [Table 95 – Additional Entries Specific to a Type 1 Form Dictionary](lib/ISO_32000/Table_95-Additional_Entries_Specific_to_a_Type_1_Form_Dictionary.rakumod) [Table 127 – Additional entries in an embedded font stream dictionary](lib/ISO_32000/Table_127-Additional_entries_in_an_embedded_font_stream_dictionary.rakumod) [Table 316 – Additional entry for components having metadata](lib/ISO_32000/Table_316-Additional_entry_for_components_having_metadata.rakumod) |
| /MissingWidth | [Table 122 – Entries common to all font descriptors](lib/ISO_32000/Table_122-Entries_common_to_all_font_descriptors.rakumod) |
| /Mix | [Table 208 – Additional entries specific to a sound action](lib/ISO_32000/Table_208-Additional_entries_specific_to_a_sound_action.rakumod) |
| /MixingHints | [Table 71 – Entries in a DeviceN Colour Space Attributes Dictionary](lib/ISO_32000/Table_71-Entries_in_a_DeviceN_Colour_Space_Attributes_Dictionary.rakumod) |
| /ModDate | [Table 46 – Entries in an embedded file parameter dictionary](lib/ISO_32000/Table_46-Entries_in_an_embedded_file_parameter_dictionary.rakumod) [Table 317 – Entries in the document information dictionary](lib/ISO_32000/Table_317-Entries_in_the_document_information_dictionary.rakumod) |
| /Mode | [Table 296 – Entries in a movie activation dictionary](lib/ISO_32000/Table_296-Entries_in_a_movie_activation_dictionary.rakumod) |
| /Movie | [Table 186 – Additional entries specific to a movie annotation](lib/ISO_32000/Table_186-Additional_entries_specific_to_a_movie_annotation.rakumod) |
| /MovieActions | [Table 259 – Entries in a legal attestation dictionary](lib/ISO_32000/Table_259-Entries_in_a_legal_attestation_dictionary.rakumod) |
| /Msg | [Table 255 – Entries in the UR transform parameters dictionary](lib/ISO_32000/Table_255-Entries_in_the_UR_transform_parameters_dictionary.rakumod) |
| /N | [Table F.1 – Entries in the linearization parameter dictionary](lib/ISO_32000/Table_F1-Entries_in_the_linearization_parameter_dictionary.rakumod) [Table 16 – Additional entries specific to an object stream dictionary](lib/ISO_32000/Table_16-Additional_entries_specific_to_an_object_stream_dictionary.rakumod) [Table 40 – Additional entries specific to a type 2 function dictionary](lib/ISO_32000/Table_40-Additional_entries_specific_to_a_type_2_function_dictionary.rakumod) [Table 66 – Additional Entries Specific to an ICC Profile Stream Dictionary](lib/ISO_32000/Table_66-Additional_Entries_Specific_to_an_ICC_Profile_Stream_Dictionary.rakumod) [Table 157 – Entries in a collection field dictionary](lib/ISO_32000/Table_157-Entries_in_a_collection_field_dictionary.rakumod) [Table 161 – Entries in a bead dictionary](lib/ISO_32000/Table_161-Entries_in_a_bead_dictionary.rakumod) [Table 168 – Entries in an appearance dictionary](lib/ISO_32000/Table_168-Entries_in_an_appearance_dictionary.rakumod) [Table 202 – Entries specific to a target dictionary](lib/ISO_32000/Table_202-Entries_specific_to_a_target_dictionary.rakumod) [Table 212 – Additional entries specific to named actions](lib/ISO_32000/Table_212-Additional_entries_specific_to_named_actions.rakumod) [Table 266 – Entries common to all rendition dictionaries](lib/ISO_32000/Table_266-Entries_common_to_all_rendition_dictionaries.rakumod) [Table 273 – Entries common to all media clip dictionaries](lib/ISO_32000/Table_273-Entries_common_to_all_media_clip_dictionaries.rakumod) [Table 305 – Entries in a projection dictionary](lib/ISO_32000/Table_305-Entries_in_a_projection_dictionary.rakumod) [Table 312 – Entries in a 3D node dictionary](lib/ISO_32000/Table_312-Entries_in_a_ThreeD_node_dictionary.rakumod) [Table 329 – Entries in a user property dictionary](lib/ISO_32000/Table_329-Entries_in_a_user_property_dictionary.rakumod) |
| /NA | [Table 163 – Entries in a navigation node dictionary](lib/ISO_32000/Table_163-Entries_in_a_navigation_node_dictionary.rakumod) [Table 304 – Entries in a 3D view dictionary](lib/ISO_32000/Table_304-Entries_in_a_ThreeD_view_dictionary.rakumod) |
| /NM | [Table 164 – Entries common to all annotation dictionaries](lib/ISO_32000/Table_164-Entries_common_to_all_annotation_dictionaries.rakumod) |
| /NP | [Table 299 – Entries in a 3D activation dictionary](lib/ISO_32000/Table_299-Entries_in_a_ThreeD_activation_dictionary.rakumod) |
| /NR | [Table 304 – Entries in a 3D view dictionary](lib/ISO_32000/Table_304-Entries_in_a_ThreeD_view_dictionary.rakumod) |
| /NU | [Table 290 – Entries in a media players dictionary](lib/ISO_32000/Table_290-Entries_in_a_media_players_dictionary.rakumod) |
| /Name | [Table 14 – Optional parameters for Crypt filters](lib/ISO_32000/Table_14-Optional_parameters_for_Crypt_filters.rakumod) [Table 89 – Additional Entries Specific to an Image Dictionary](lib/ISO_32000/Table_89-Additional_Entries_Specific_to_an_Image_Dictionary.rakumod) [Table 95 – Additional Entries Specific to a Type 1 Form Dictionary](lib/ISO_32000/Table_95-Additional_Entries_Specific_to_a_Type_1_Form_Dictionary.rakumod) [Table 98 – Entries in an Optional Content Group Dictionary](lib/ISO_32000/Table_98-Entries_in_an_Optional_Content_Group_Dictionary.rakumod) [Table 101 – Entries in an Optional Content Configuration Dictionary](lib/ISO_32000/Table_101-Entries_in_an_Optional_Content_Configuration_Dictionary.rakumod) [Table 111 – Entries in a Type 1 font dictionary](lib/ISO_32000/Table_111-Entries_in_a_Type_1_font_dictionary.rakumod) [Table 112 – Entries in a Type 3 font dictionary](lib/ISO_32000/Table_112-Entries_in_a_Type_3_font_dictionary.rakumod) [Table 172 – Additional entries specific to a text annotation](lib/ISO_32000/Table_172-Additional_entries_specific_to_a_text_annotation.rakumod) [Table 181 – Additional entries specific to a rubber stamp annotation](lib/ISO_32000/Table_181-Additional_entries_specific_to_a_rubber_stamp_annotation.rakumod) [Table 184 – Additional entries specific to a file attachment annotation](lib/ISO_32000/Table_184-Additional_entries_specific_to_a_file_attachment_annotation.rakumod) [Table 185 – Additional entries specific to a sound annotation](lib/ISO_32000/Table_185-Additional_entries_specific_to_a_sound_annotation.rakumod) [Table 250 – Entries in an FDF named page reference dictionary](lib/ISO_32000/Table_250-Entries_in_an_FDF_named_page_reference_dictionary.rakumod) [Table 252 – Entries in a signature dictionary](lib/ISO_32000/Table_252-Entries_in_a_signature_dictionary.rakumod) [Table 260 – Entries in a viewport dictionary](lib/ISO_32000/Table_260-Entries_in_a_viewport_dictionary.rakumod) |
| /Names | [Table 28 – Entries in the |
## dist_zef-dwarring-PDF-ISO_32000.md
## Chunk 7 of 10
catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) [Table 36 – Entries in a name tree node dictionary](lib/ISO_32000/Table_36-Entries_in_a_name_tree_node_dictionary.rakumod) |
| /NeedAppearances | [Table 218 – Entries in the interactive form dictionary](lib/ISO_32000/Table_218-Entries_in_the_interactive_form_dictionary.rakumod) |
| /NeedsRendering | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) |
| /NewWindow | [Table 200 – Additional entries specific to a remote go-to action](lib/ISO_32000/Table_200-Additional_entries_specific_to_a_remote_go-to_action.rakumod) [Table 201 – Additional entries specific to an embedded go-to action](lib/ISO_32000/Table_201-Additional_entries_specific_to_an_embedded_go-to_action.rakumod) [Table 203 – Additional entries specific to a launch action](lib/ISO_32000/Table_203-Additional_entries_specific_to_a_launch_action.rakumod) |
| /Next | [Table 153 – Entries in an outline item dictionary](lib/ISO_32000/Table_153-Entries_in_an_outline_item_dictionary.rakumod) [Table 163 – Entries in a navigation node dictionary](lib/ISO_32000/Table_163-Entries_in_a_navigation_node_dictionary.rakumod) [Table 193 – Entries common to all action dictionaries](lib/ISO_32000/Table_193-Entries_common_to_all_action_dictionaries.rakumod) |
| /NonEmbeddedFonts | [Table 259 – Entries in a legal attestation dictionary](lib/ISO_32000/Table_259-Entries_in_a_legal_attestation_dictionary.rakumod) |
| /NonFullScreenPageMode | [Table 150 – Entries in a viewer preferences dictionary](lib/ISO_32000/Table_150-Entries_in_a_viewer_preferences_dictionary.rakumod) |
| /NumCopies | [Table 150 – Entries in a viewer preferences dictionary](lib/ISO_32000/Table_150-Entries_in_a_viewer_preferences_dictionary.rakumod) |
| /Nums | [Table 37 – Entries in a number tree node dictionary](lib/ISO_32000/Table_37-Entries_in_a_number_tree_node_dictionary.rakumod) |
| /O | [Table F.1 – Entries in the linearization parameter dictionary](lib/ISO_32000/Table_F1-Entries_in_the_linearization_parameter_dictionary.rakumod) [Table 21 – Additional encryption dictionary entries for the standard security handler](lib/ISO_32000/Table_21-Additional_encryption_dictionary_entries_for_the_standard_security_handler.rakumod) [Table 157 – Entries in a collection field dictionary](lib/ISO_32000/Table_157-Entries_in_a_collection_field_dictionary.rakumod) [Table 195 – Entries in a page object’s additional-actions dictionary](lib/ISO_32000/Table_195-Entries_in_a_page_objects_additional-actions_dictionary.rakumod) [Table 204 – Entries in a Windows launch parameter dictionary](lib/ISO_32000/Table_204-Entries_in_a_Windows_launch_parameter_dictionary.rakumod) [Table 262 – Additional entries in a rectilinear measure dictionary](lib/ISO_32000/Table_262-Additional_entries_in_a_rectilinear_measure_dictionary.rakumod) [Table 263 – Entries in a number format dictionary](lib/ISO_32000/Table_263-Entries_in_a_number_format_dictionary.rakumod) [Table 268 – Entries in a media criteria dictionary](lib/ISO_32000/Table_268-Entries_in_a_media_criteria_dictionary.rakumod) [Table 283 – Entries in a media screen parameters MH/BE dictionary](lib/ISO_32000/Table_283-Entries_in_a_media_screen_parameters_MH-BE_dictionary.rakumod) [Table 284 – Entries in a floating window parameters dictionary](lib/ISO_32000/Table_284-Entries_in_a_floating_window_parameters_dictionary.rakumod) [Table 304 – Entries in a 3D view dictionary](lib/ISO_32000/Table_304-Entries_in_a_ThreeD_view_dictionary.rakumod) [Table 307 – Entries in a render mode dictionary](lib/ISO_32000/Table_307-Entries_in_a_render_mode_dictionary.rakumod) [Table 311 – Entries in a 3D cross section dictionary](lib/ISO_32000/Table_311-Entries_in_a_ThreeD_cross_section_dictionary.rakumod) [Table 312 – Entries in a 3D node dictionary](lib/ISO_32000/Table_312-Entries_in_a_ThreeD_node_dictionary.rakumod) [Table 327 – Entry common to all attribute object dictionaries](lib/ISO_32000/Table_327-Entry_common_to_all_attribute_object_dictionaries.rakumod) [Table 328 – Additional entries in an attribute object dictionary for user properties](lib/ISO_32000/Table_328-Additional_entries_in_an_attribute_object_dictionary_for_user_properties.rakumod) [Table 352 – Entries common to all Web Capture content sets](lib/ISO_32000/Table_352-Entries_common_to_all_Web_Capture_content_sets.rakumod) |
| /OB | [Table 305 – Entries in a projection dictionary](lib/ISO_32000/Table_305-Entries_in_a_projection_dictionary.rakumod) |
| /OC | [Table 89 – Additional Entries Specific to an Image Dictionary](lib/ISO_32000/Table_89-Additional_Entries_Specific_to_an_Image_Dictionary.rakumod) [Table 91 – Entries in an Alternate Image Dictionary](lib/ISO_32000/Table_91-Entries_in_an_Alternate_Image_Dictionary.rakumod) [Table 95 – Additional Entries Specific to a Type 1 Form Dictionary](lib/ISO_32000/Table_95-Additional_Entries_Specific_to_a_Type_1_Form_Dictionary.rakumod) [Table 164 – Entries common to all annotation dictionaries](lib/ISO_32000/Table_164-Entries_common_to_all_annotation_dictionaries.rakumod) |
| /OCGs | [Table 99 – Entries in an Optional Content Membership Dictionary](lib/ISO_32000/Table_99-Entries_in_an_Optional_Content_Membership_Dictionary.rakumod) [Table 100 – Entries in the Optional Content Properties Dictionary](lib/ISO_32000/Table_100-Entries_in_the_Optional_Content_Properties_Dictionary.rakumod) [Table 103 – Entries in a Usage Application Dictionary](lib/ISO_32000/Table_103-Entries_in_a_Usage_Application_Dictionary.rakumod) |
| /OCProperties | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) |
| /OFF | [Table 101 – Entries in an Optional Content Configuration Dictionary](lib/ISO_32000/Table_101-Entries_in_an_Optional_Content_Configuration_Dictionary.rakumod) |
| /OID | [Table 235 – Entries in a certificate seed value dictionary](lib/ISO_32000/Table_235-Entries_in_a_certificate_seed_value_dictionary.rakumod) |
| /ON | [Table 101 – Entries in an Optional Content Configuration Dictionary](lib/ISO_32000/Table_101-Entries_in_an_Optional_Content_Configuration_Dictionary.rakumod) |
| /OP | [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) [Table 214 – Additional entries specific to a rendition action](lib/ISO_32000/Table_214-Additional_entries_specific_to_a_rendition_action.rakumod) |
| /OPI | [Table 89 – Additional Entries Specific to an Image Dictionary](lib/ISO_32000/Table_89-Additional_Entries_Specific_to_an_Image_Dictionary.rakumod) [Table 95 – Additional Entries Specific to a Type 1 Form Dictionary](lib/ISO_32000/Table_95-Additional_Entries_Specific_to_a_Type_1_Form_Dictionary.rakumod) |
| /OPM | [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) |
| /OS | [Table 292 – Entries in a software identifier dictionary](lib/ISO_32000/Table_292-Entries_in_a_software_identifier_dictionary.rakumod) [Table 305 – Entries in a projection dictionary](lib/ISO_32000/Table_305-Entries_in_a_projection_dictionary.rakumod) |
| /Obj | [Table 325 – Entries in an object reference dictionary](lib/ISO_32000/Table_325-Entries_in_an_object_reference_dictionary.rakumod) |
| /OnInstantiate | [Table 300 – Entries in a 3D stream dictionary](lib/ISO_32000/Table_300-Entries_in_a_ThreeD_stream_dictionary.rakumod) |
| /Open | [Table 172 – Additional entries specific to a text annotation](lib/ISO_32000/Table_172-Additional_entries_specific_to_a_text_annotation.rakumod) [Table 183 – Additional entries specific to a pop-up annotation](lib/ISO_32000/Table_183-Additional_entries_specific_to_a_pop-up_annotation.rakumod) |
| /OpenAction | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) |
| /Operation | [Table 209 – Additional entries specific to a movie action](lib/ISO_32000/Table_209-Additional_entries_specific_to_a_movie_action.rakumod) |
| /Opt | [Table 227 – Additional entry specific to check box and radio button fields](lib/ISO_32000/Table_227-Additional_entry_specific_to_check_box_and_radio_button_fields.rakumod) [Table 231 – Additional entries specific to a choice field](lib/ISO_32000/Table_231-Additional_entries_specific_to_a_choice_field.rakumod) [Table 246 – Entries in an FDF field dictionary](lib/ISO_32000/Table_246-Entries_in_an_FDF_field_dictionary.rakumod) |
| /OptionalContent | [Table 259 – Entries in a legal attestation dictionary](lib/ISO_32000/Table_259-Entries_in_a_legal_attestation_dictionary.rakumod) |
| /Order | [Table 39 – Additional entries specific to a type 0 function dictionary](lib/ISO_32000/Table_39-Additional_entries_specific_to_a_type_0_function_dictionary.rakumod) [Table 101 – Entries in an Optional Content Configuration Dictionary](lib/ISO_32000/Table_101-Entries_in_an_Optional_Content_Configuration_Dictionary.rakumod) |
| /Ordering | [Table 116 – Entries in a CIDSystemInfo dictionary](lib/ISO_32000/Table_116-Entries_in_a_CIDSystemInfo_dictionary.rakumod) |
| /Outlines | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) |
| /OutputCondition | [Table 365 – Entries in an output intent dictionary](lib/ISO_32000/Table_365-Entries_in_an_output_intent_dictionary.rakumod) |
| /OutputConditionIdentifier | [Table 365 – Entries in an output intent dictionary](lib/ISO_32000/Table_365-Entries_in_an_output_intent_dictionary.rakumod) |
| /OutputIntents | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) |
| /OverlayText | [Table 192 – Additional entries specific to a redaction annotation](lib/ISO_32000/Table_192-Additional_entries_specific_to_a_redaction_annotation.rakumod) |
| /P | [Table F.1 – Entries in the linearization parameter dictionary](lib/ISO_32000/Table_F1-Entries_in_the_linearization_parameter_dictionary.rakumod) [Table 21 – Additional encryption dictionary entries for the standard security handler](lib/ISO_32000/Table_21-Additional_encryption_dictionary_entries_for_the_standard_security_handler.rakumod) [Table 23 – Additional encryption dictionary entries for public-key security handlers](lib/ISO_32000/Table_23-Additional_encryption_dictionary_entries_for_public-key_security_handlers.rakumod) [Table 49 – Entries in a collection subitem dictionary](lib/ISO_32000/Table_49-Entries_in_a_collection_subitem_dictionary.rakumod) [Table 99 – Entries in an Optional Content Membership Dictionary](lib/ISO_32000/Table_99-Entries_in_an_Optional_Content_Membership_Dictionary.rakumod) [Table 159 – Entries in a page label dictionary](lib/ISO_32000/Table_159-Entries_in_a_page_label_dictionary.rakumod) [Table 161 – Entries in a bead dictionary](lib/ISO_32000/Table_161-Entries_in_a_bead_dictionary.rakumod) [Table 164 – Entries common to all annotation dictionaries](lib/ISO_32000/Table_164-Entries_common_to_all_annotation_dictionaries.rakumod) [Table 202 – Entries specific to a target dictionary](lib/ISO_32000/Table_202-Entries_specific_to_a_target_dictionary.rakumod) [Table 204 – Entries in a Windows launch parameter dictionary](lib/ISO_32000/Table_204-Entries_in_a_Windows_launch_parameter_dictionary.rakumod) [Table 254 – Entries in the DocMDP transform parameters dictionary](lib/ISO_32000/Table_254-Entries_in_the_DocMDP_transform_parameters_dictionary.rakumod) [Table 255 – Entries in the UR transform parameters dictionary](lib/ISO_32000/Table_255-Entries_in_the_UR_transform_parameters_dictionary.rakumod) [Table 268 – Entries in a media criteria dictionary](lib/ISO_32000/Table_268-Entries_in_a_media_criteria_dictionary.rakumod) [Table 271 – Additional entries in a media rendition dictionary](lib/ISO_32000/Table_271-Additional_entries_in_a_media_rendition_dictionary.rakumod) [Table 274 – Additional entries in a media clip data dictionary](lib/ISO_32000/Table_274-Additional_entries_in_a_media_clip_data_dictionary.rakumod) [Table 284 – Entries in a floating window parameters dictionary](lib/ISO_32000/Table_284-Entries_in_a_floating_window_parameters_dictionary.rakumod) [Table 304 – Entries in a 3D view dictionary](lib/ISO_32000/Table_304-Entries_in_a_ThreeD_view_dictionary.rakumod) [Table 323 – Entries in a structure element dictionary](lib/ISO_32000/Table_323-Entries_in_a_structure_element_dictionary.rakumod) [Table 328 – Additional entries in an attribute object dictionary for user properties](lib/ISO_32000/Table_328-Additional_entries_in_an_attribute_object_dictionary_for_user_properties.rakumod) [Table 357 – Entries in a Web Capture command dictionary](lib/ISO_32000/Table_357-Entries_in_a_Web_Capture_command_dictionary.rakumod) |
| /PA | [Table 163 – Entries in a navigation node dictionary](lib/ISO_32000/Table_163-Entries_in_a_navigation_node_dictionary.rakumod) [Table 173 – Additional entries specific to a link annotation](lib/ISO_32000/Table_173-Additional_entries_specific_to_a_link_annotation.rakumod) |
| /PC | [Table 194 – Entries in an annotation’s additional-actions dictionary](lib/ISO_32000/Table_194-Entries_in_an_annotations_additional-actions_dictionary.rakumod) [Table 301 – Entries in an 3D animation style dictionary](lib/ISO_32000/Table_301-Entries_in_an_ThreeD_animation_style_dictionary.rakumod) [Table 311 – Entries in a 3D cross section dictionary](lib/ISO_32000/Table_311-Entries_in_a_ThreeD_cross_section_dictionary.rakumod) |
| /PCM | [Table 367 – Additional entries specific to a trap network appearance stream](lib/ISO_32000/Table_367-Additional_entries_specific_to_a_trap_network_appearance_stream.rakumod) |
| /PI | [Table 194 – Entries in an annotation’s additional-actions dictionary](lib/ISO_32000/Table_194-Entries_in_an_annotations_additional-actions_dictionary.rakumod) |
| /PID | [Table 291 – Entries in a media player info dictionary](lib/ISO_32000/Table_291-Entries_in_a_media_player_info_dictionary.rakumod) |
| /PL | [Table 274 – Additional entries in a media clip data dictionary](lib/ISO_32000/Table_274-Additional_entries_in_a_media_clip_data_dictionary.rakumod) [Table 279 – Entries in a media play parameters dictionary](lib/ISO_32000/Table_279-Entries_in_a_media_play_parameters_dictionary.rakumod) |
| /PO | [Table 194 – Entries in an annotation’s additional-actions dictionary](lib/ISO_32000/Table_194-Entries_in_an_annotations_additional-actions_dictionary.rakumod) [Table 311 – Entries in a 3D cross section dictionary](lib/ISO_32000/Table_311-Entries_in_a_ThreeD_cross_section_dictionary.rakumod) |
| /PS | [Table 263 – Entries in a number format dictionary](lib/ISO_32000/Table_263-Entries_in_a_number_format_dictionary.rakumod) [Table 305 – Entries in a projection dictionary](lib/ISO_32000/Table_305-Entries_in_a_projection_dictionary.rakumod) |
| /PV | [Table 194 – Entries in an annotation’s additional-actions dictionary](lib/ISO_32000/Table_194-Entries_in_an_annotations_additional-actions_dictionary.rakumod) |
| /PZ | [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) |
| /Padding | [Table 343 – Standard layout attributes common to all standard structure types](lib/ISO_32000/Table_343-Standard_layout_attributes_common_to_all_standard_structure_types.rakumod) |
| /Page | [Table 97 – Entries in a Reference Dictionary](lib/ISO_32000/Table_97-Entries_in_a_Reference_Dictionary.rakumod) [Table 251 – Additional entry for annotation dictionaries in an FDF file](lib/ISO_32000/Table_251-Additional_entry_for_annotation_dictionaries_in_an_FDF_file.rakumod) |
| /PageElement | [Table 102 – Entries in an Optional Content Usage Dictionary](lib/ISO_32000/Table_102-Entries_in_an_Optional_Content_Usage_Dictionary.rakumod) |
| /PageLabels | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) |
| /PageLayout | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) |
| /PageMode | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) |
| /Pages | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) [Table 31 – Entries in the name dictionary](lib/ISO_32000/Table_31-Entries_in_the_name_dictionary.rakumod) [Table 243 – Entries in the FDF dictionary](lib/ISO_32000/Table_243-Entries_in_the_FDF_dictionary.rakumod) [Table 364 – Entries in a separation dictionary](lib/ISO_32000/Table_364-Entries_in_a_separation_dictionary.rakumod) |
| /PaintType | [Table 75 – Additional Entries Specific to a Type 1 Pattern Dictionary](lib/ISO_32000/Table_75-Additional_Entries_Specific_to_a_Type_1_Pattern_Dictionary.rakumod) |
| /Params | [Table 45 – Additional entries in an embedded file stream dictionary](lib/ISO_32000/Table_45-Additional_entries_in_an_embedded_file_stream_dictionary.rakumod) |
| /Parent | [Table 29 – Required entries in a page tree node](lib/ISO_32000/Table_29-Required_entries_in_a_page_tree_node.rakumod) [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) [Table 153 – Entries in an outline item dictionary](lib/ISO_32000/Table_153-Entries_in_an_outline_item_dictionary.rakumod) [Table 183 – Additional entries specific to a pop-up annotation](lib/ISO_32000/Table_183-Additional_entries_specific_to_a_pop-up_annotation.rakumod) [Table 188 – Additional entries specific to a widget annotation](lib/ISO_32000/Table_188-Additional_entries_specific_to_a_widget_annotation.rakumod) [Table 220 – Entries common to all field dictionaries](lib/ISO_32000/Table_220-Entries_common_to_all_field_dictionaries.rakumod) |
| /ParentTree | [Table 322 – Entries in the structure tree root](lib/ISO_32000/Table_322-Entries_in_the_structure_tree_root.rakumod) |
| /ParentTreeNextKey | [Table 322 – Entries in the structure tree root](lib/ISO_32000/Table_322-Entries_in_the_structure_tree_root.rakumod) |
| /Pattern | [Table 33 – Entries in a resource dictionary](lib/ISO_32000/Table_33-Entries_in_a_resource_dictionary.rakumod) |
| /PatternType | [Table 75 – Additional Entries Specific to a Type 1 Pattern Dictionary](lib/ISO_32000/Table_75-Additional_Entries_Specific_to_a_Type_1_Pattern_Dictionary.rakumod) [Table 76 – Entries in a Type 2 Pattern Dictionary](lib/ISO_32000/Table_76-Entries_in_a_Type_2_Pattern_Dictionary.rakumod) |
| /Perms | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) |
| /Pg | [Table 323 – Entries in a structure element dictionary](lib/ISO_32000/Table_323-Entries_in_a_structure_element_dictionary.rakumod) [Table 324 – Entries in a marked-content reference dictionary](lib/ISO_32000/Table_324-Entries_in_a_marked-content_reference_dictionary.rakumod) [Table 325 – Entries in an object reference dictionary](lib/ISO_32000/Table_325-Entries_in_an_object_reference_dictionary.rakumod) |
| /PickTrayByPDFSize | [Table 150 – Entries in a viewer preferences dictionary](lib/ISO_32000/Table_150-Entries_in_a_viewer_preferences_dictionary.rakumod) |
| /PieceInfo | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) [Table 95 – Additional Entries Specific to a Type 1 Form Dictionary](lib/ISO_32000/Table_95-Additional_Entries_Specific_to_a_Type_1_Form_Dictionary.rakumod) |
| /Placement | [Table 343 – Standard layout attributes common to all standard structure types](lib/ISO_32000/Table_343-Standard_layout_attributes_common_to_all_standard_structure_types.rakumod) |
| /Popup | [Table 170 – Additional entries specific to markup annotations](lib/ISO_32000/Table_170-Additional_entries_specific_to_markup_annotations.rakumod) |
| /Poster | [Table 295 – Entries in a movie dictionary](lib/ISO_32000/Table_295-Entries_in_a_movie_dictionary.rakumod) |
| /Predictor | [Table 8 – Optional parameters for LZWDecode and FlateDecode filters](lib/ISO_32000/Table_8-Optional_parameters_for_LZWDecode_and_FlateDecode_filters.rakumod) |
| /PresSteps | [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) |
| /PreserveRB | [Table 213 – Additional entries specific to a set-OCG-state action](lib/ISO_32000/Table_213-Additional_entries_specific_to_a_set-OCG-state_action.rakumod) |
| /Prev | [Table 15 – Entries in the file trailer dictionary](lib/ISO_32000/Table_15-Entries_in_the_file_trailer_dictionary.rakumod) [Table 17 – Additional entries specific to a cross-reference stream dictionary](lib/ISO_32000/Table_17-Additional_entries_specific_to_a_cross-reference_stream_dictionary.rakumod) [Table 153 – Entries in an outline item dictionary](lib/ISO_32000/Table_153-Entries_in_an_outline_item_dictionary.rakumod) [Table 163 – Entries in a navigation node dictionary](lib/ISO_32000/Table_163-Entries_in_a_navigation_node_dictionary.rakumod) |
| /Print | [Table 102 – Entries in an Optional Content Usage Dictionary](lib/ISO_32000/Table_102-Entries_in_an_Optional_Content_Usage_Dictionary.rakumod) |
| /PrintArea | [Table 150 – Entries in a viewer preferences dictionary](lib/ISO_32000/Table_150-Entries_in_a_viewer_preferences_dictionary.rakumod) |
| /PrintClip | [Table 150 – Entries in a viewer preferences dictionary](lib/ISO_32000/Table_150-Entries_in_a_viewer_preferences_dictionary.rakumod) |
| /PrintPageRange | [Table 150 – Entries in a viewer preferences dictionary](lib/ISO_32000/Table_150-Entries_in_a_viewer_preferences_dictionary.rakumod) |
| /PrintScaling | [Table 150 – Entries in a viewer preferences dictionary](lib/ISO_32000/Table_150-Entries_in_a_viewer_preferences_dictionary.rakumod) |
| /PrintingOrder | [Table 73 – Entries in a DeviceN Mixing Hints Dictionary](lib/ISO_32000/Table_73-Entries_in_a_DeviceN_Mixing_Hints_Dictionary.rakumod) |
| /Private | [Table 319 – Entries in an data dictionary](lib/ISO_32000/Table_319-Entries_in_an_data_dictionary.rakumod) |
| /ProcSet | [Table 33 – Entries in a resource dictionary](lib/ISO_32000/Table_33-Entries_in_a_resource_dictionary.rakumod) |
| /Process | [Table 71 – Entries in a DeviceN Colour Space Attributes Dictionary](lib/ISO_32000/Table_71-Entries_in_a_DeviceN_Colour_Space_Attributes_Dictionary.rakumod) |
| /Producer | [Table 317 – Entries in the document information dictionary](lib/ISO_32000/Table_317-Entries_in_the_document_information_dictionary.rakumod) |
| /Prop\_AuthTime | [Table 252 – Entries in a signature dictionary](lib/ISO_32000/Table_252-Entries_in_a_signature_dictionary.rakumod) |
| /Prop\_AuthType | [Table 252 – Entries in a signature dictionary](lib/ISO_32000/Table_252-Entries_in_a_signature_dictionary.rakumod) |
| /Prop\_Build | [Table 252 – Entries in a signature dictionary](lib/ISO_32000/Table_252-Entries_in_a_signature_dictionary.rakumod) |
| /Properties | [Table 33 – Entries in a resource dictionary](lib/ISO_32000/Table_33-Entries_in_a_resource_dictionary.rakumod) |
| /Q | [Table 174 – Additional entries specific to a free text annotation](lib/ISO_32000/Table_174-Additional_entries_specific_to_a_free_text_annotation.rakumod) [Table 192 – Additional entries specific to a redaction annotation](lib/ISO_32000/Table_192-Additional_entries_specific_to_a_redaction_annotation.rakumod) [Table 218 – Entries in the interactive form dictionary](lib/ISO_32000/Table_218-Entries_in_the_interactive_form_dictionary.rakumod) [Table 222 – Additional entries common to all fields containing variable text](lib/ISO_32000/Table_222-Additional_entries_common_to_all_fields_containing_variable_text.rakumod) |
| /QuadPoints | [Table 173 – Additional entries specific to a link annotation](lib/ISO_32000/Table_173-Additional_entries_specific_to_a_link_annotation.rakumod) [Table 179 – Additional entries specific to text markup annotations](lib/ISO_32000/Table_179-Additional_entries_specific_to_text_markup_annotations.rakumod) [Table 192 – Additional entries specific to a redaction annotation](lib/ISO_32000/Table_192-Additional_entries_specific_to_a_redaction_annotation.rakumod) |
| /R | [Table 21 – Additional encryption dictionary entries for the standard security handler](lib/ISO_32000/Table_21-Additional_encryption_dictionary_entries_for_the_standard_security_handler.rakumod) [Table 161 – Entries in a bead dictionary](lib/ISO_32000/Table_161-Entries_in_a_bead_dictionary.rakumod) [Table 168 – Entries in an appearance dictionary](lib/ISO_32000/Table_168-Entries_in_an_appearance_dictionary.rakumod) [Table 189 – Entries in an appearance characteristics dictionary](lib/ISO_32000/Table_189-Entries_in_an_appearance_characteristics_dictionary.rakumod) [Table 202 – Entries specific to a target dictionary](lib/ISO_32000/Table_202-Entries_specific_to_a_target_dictionary.rakumod) [Table 214 – Additional entries specific to a rendition action](lib/ISO_32000/Table_214-Additional_entries_specific_to_a_rendition_action.rakumod) [Table 252 – Entries in a signature dictionary](lib/ISO_32000/Table_252-Entries_in_a_signature_dictionary.rakumod) [Table 262 – Additional entries in a rectilinear measure dictionary](lib/ISO_32000/Table_262-Additional_entries_in_a_rectilinear_measure_dictionary.rakumod) [Table 268 – Entries in a media criteria dictionary](lib/ISO_32000/Table_268-Entries_in_a_media_criteria_dictionary.rakumod) [Table 272 – Additional entries specific to a selector rendition dictionary](lib/ISO_32000/Table_272-Additional_entries_specific_to_a_selector_rendition_dictionary.rakumod) [Table 284 – Entries in a floating window parameters dictionary](lib/ISO_32000/Table_284-Entries_in_a_floating_window_parameters_dictionary.rakumod) [Table 294 – Additional entries specific to a sound object](lib/ISO_32000/Table_294-Additional_entries_specific_to_a_sound_object.rakumod) [Table 323 – Entries in a structure element dictionary](lib/ISO_32000/Table_323-Entries_in_a_structure_element_dictionary.rakumod) [Table 354 – Additional entries specific to a Web Capture image set](lib/ISO_32000/Table_354-Additional_entries_specific_to_a_Web_Capture_image_set.rakumod) |
| /RBGroups | [Table 101 – Entries in an Optional Content Configuration Dictionary](lib/ISO_32000/Table_101-Entries_in_an_Optional_Content_Configuration_Dictionary.rakumod) |
| /RC | [Table 170 – Additional entries specific to markup annotations](lib/ISO_32000 |
## dist_zef-dwarring-PDF-ISO_32000.md
## Chunk 8 of 10
/Table_170-Additional_entries_specific_to_markup_annotations.rakumod) [Table 174 – Additional entries specific to a free text annotation](lib/ISO_32000/Table_174-Additional_entries_specific_to_a_free_text_annotation.rakumod) [Table 189 – Entries in an appearance characteristics dictionary](lib/ISO_32000/Table_189-Entries_in_an_appearance_characteristics_dictionary.rakumod) [Table 280 – Entries in a media play parameters MH/BE dictionary](lib/ISO_32000/Table_280-Entries_in_a_media_play_parameters_MH-BE_dictionary.rakumod) |
| /RD | [Table 174 – Additional entries specific to a free text annotation](lib/ISO_32000/Table_174-Additional_entries_specific_to_a_free_text_annotation.rakumod) [Table 177 – Additional entries specific to a square or circle annotation](lib/ISO_32000/Table_177-Additional_entries_specific_to_a_square_or_circle_annotation.rakumod) [Table 180 – Additional entries specific to a caret annotation](lib/ISO_32000/Table_180-Additional_entries_specific_to_a_caret_annotation.rakumod) [Table 263 – Entries in a number format dictionary](lib/ISO_32000/Table_263-Entries_in_a_number_format_dictionary.rakumod) |
| /RF | [Table 44 – Entries in a file specification dictionary](lib/ISO_32000/Table_44-Entries_in_a_file_specification_dictionary.rakumod) |
| /RH | [Table 264 – Entries common to all requirement dictionaries](lib/ISO_32000/Table_264-Entries_common_to_all_requirement_dictionaries.rakumod) |
| /RI | [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) [Table 189 – Entries in an appearance characteristics dictionary](lib/ISO_32000/Table_189-Entries_in_an_appearance_characteristics_dictionary.rakumod) |
| /RM | [Table 304 – Entries in a 3D view dictionary](lib/ISO_32000/Table_304-Entries_in_a_ThreeD_view_dictionary.rakumod) |
| /RO | [Table 192 – Additional entries specific to a redaction annotation](lib/ISO_32000/Table_192-Additional_entries_specific_to_a_redaction_annotation.rakumod) |
| /RT | [Table 170 – Additional entries specific to markup annotations](lib/ISO_32000/Table_170-Additional_entries_specific_to_markup_annotations.rakumod) [Table 263 – Entries in a number format dictionary](lib/ISO_32000/Table_263-Entries_in_a_number_format_dictionary.rakumod) [Table 284 – Entries in a floating window parameters dictionary](lib/ISO_32000/Table_284-Entries_in_a_floating_window_parameters_dictionary.rakumod) |
| /RV | [Table 222 – Additional entries common to all fields containing variable text](lib/ISO_32000/Table_222-Additional_entries_common_to_all_fields_containing_variable_text.rakumod) [Table 246 – Entries in an FDF field dictionary](lib/ISO_32000/Table_246-Entries_in_an_FDF_field_dictionary.rakumod) |
| /Range | [Table 38 – Entries common to all function dictionaries](lib/ISO_32000/Table_38-Entries_common_to_all_function_dictionaries.rakumod) [Table 65 – Entries in a Lab Colour Space Dictionary](lib/ISO_32000/Table_65-Entries_in_a_Lab_Colour_Space_Dictionary.rakumod) [Table 66 – Additional Entries Specific to an ICC Profile Stream Dictionary](lib/ISO_32000/Table_66-Additional_Entries_Specific_to_an_ICC_Profile_Stream_Dictionary.rakumod) |
| /Rate | [Table 296 – Entries in a movie activation dictionary](lib/ISO_32000/Table_296-Entries_in_a_movie_activation_dictionary.rakumod) |
| /Reason | [Table 252 – Entries in a signature dictionary](lib/ISO_32000/Table_252-Entries_in_a_signature_dictionary.rakumod) |
| /Reasons | [Table 234 – Entries in a signature field seed value dictionary](lib/ISO_32000/Table_234-Entries_in_a_signature_field_seed_value_dictionary.rakumod) |
| /Recipients | [Table 23 – Additional encryption dictionary entries for public-key security handlers](lib/ISO_32000/Table_23-Additional_encryption_dictionary_entries_for_public-key_security_handlers.rakumod) [Table 27 – Additional crypt filter dictionary entries for public-key security handlers](lib/ISO_32000/Table_27-Additional_crypt_filter_dictionary_entries_for_public-key_security_handlers.rakumod) |
| /Rect | [Table 164 – Entries common to all annotation dictionaries](lib/ISO_32000/Table_164-Entries_common_to_all_annotation_dictionaries.rakumod) |
| /Ref | [Table 95 – Additional Entries Specific to a Type 1 Form Dictionary](lib/ISO_32000/Table_95-Additional_Entries_Specific_to_a_Type_1_Form_Dictionary.rakumod) |
| /Reference | [Table 252 – Entries in a signature dictionary](lib/ISO_32000/Table_252-Entries_in_a_signature_dictionary.rakumod) |
| /Registry | [Table 116 – Entries in a CIDSystemInfo dictionary](lib/ISO_32000/Table_116-Entries_in_a_CIDSystemInfo_dictionary.rakumod) |
| /RegistryName | [Table 365 – Entries in an output intent dictionary](lib/ISO_32000/Table_365-Entries_in_an_output_intent_dictionary.rakumod) |
| /Rename | [Table 249 – Entries in an FDF template dictionary](lib/ISO_32000/Table_249-Entries_in_an_FDF_template_dictionary.rakumod) |
| /Renditions | [Table 31 – Entries in the name dictionary](lib/ISO_32000/Table_31-Entries_in_the_name_dictionary.rakumod) |
| /Repeat | [Table 192 – Additional entries specific to a redaction annotation](lib/ISO_32000/Table_192-Additional_entries_specific_to_a_redaction_annotation.rakumod) [Table 208 – Additional entries specific to a sound action](lib/ISO_32000/Table_208-Additional_entries_specific_to_a_sound_action.rakumod) |
| /Requirements | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) |
| /ResFork | [Table 47 – Entries in a Mac OS file information dictionary](lib/ISO_32000/Table_47-Entries_in_a_Mac_OS_file_information_dictionary.rakumod) |
| /Resources | [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) [Table 75 – Additional Entries Specific to a Type 1 Pattern Dictionary](lib/ISO_32000/Table_75-Additional_Entries_Specific_to_a_Type_1_Pattern_Dictionary.rakumod) [Table 95 – Additional Entries Specific to a Type 1 Form Dictionary](lib/ISO_32000/Table_95-Additional_Entries_Specific_to_a_Type_1_Form_Dictionary.rakumod) [Table 112 – Entries in a Type 3 font dictionary](lib/ISO_32000/Table_112-Entries_in_a_Type_3_font_dictionary.rakumod) [Table 297 – Entries in a slideshow dictionary](lib/ISO_32000/Table_297-Entries_in_a_slideshow_dictionary.rakumod) [Table 300 – Entries in a 3D stream dictionary](lib/ISO_32000/Table_300-Entries_in_a_ThreeD_stream_dictionary.rakumod) |
| /Role | [Table 348 – PrintField attributes](lib/ISO_32000/Table_348-PrintField_attributes.rakumod) |
| /RoleMap | [Table 322 – Entries in the structure tree root](lib/ISO_32000/Table_322-Entries_in_the_structure_tree_root.rakumod) |
| /Root | [Table 15 – Entries in the file trailer dictionary](lib/ISO_32000/Table_15-Entries_in_the_file_trailer_dictionary.rakumod) [Table 241 – Entry in the FDF trailer dictionary](lib/ISO_32000/Table_241-Entry_in_the_FDF_trailer_dictionary.rakumod) |
| /Rotate | [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) [Table 295 – Entries in a movie dictionary](lib/ISO_32000/Table_295-Entries_in_a_movie_dictionary.rakumod) |
| /RowSpan | [Table 349 – Standard table attributes](lib/ISO_32000/Table_349-Standard_table_attributes.rakumod) |
| /Rows | [Table 11 – Optional parameters for the CCITTFaxDecode filter](lib/ISO_32000/Table_11-Optional_parameters_for_the_CCITTFaxDecode_filter.rakumod) |
| /RubyAlign | [Table 345 – Standard layout attributes specific to inline-level structure elements](lib/ISO_32000/Table_345-Standard_layout_attributes_specific_to_inline-level_structure_elements.rakumod) |
| /RubyPosition | [Table 345 – Standard layout attributes specific to inline-level structure elements](lib/ISO_32000/Table_345-Standard_layout_attributes_specific_to_inline-level_structure_elements.rakumod) |
| /S | [Table 96 – Entries Common to all Group Attributes Dictionaries](lib/ISO_32000/Table_96-Entries_Common_to_all_Group_Attributes_Dictionaries.rakumod) [Table 144 – Entries in a soft-mask dictionary](lib/ISO_32000/Table_144-Entries_in_a_soft-mask_dictionary.rakumod) [Table 147 – Additional entries specific to a transparency group attributes dictionary](lib/ISO_32000/Table_147-Additional_entries_specific_to_a_transparency_group_attributes_dictionary.rakumod) [Table 158 – Entries in a collection sort dictionary](lib/ISO_32000/Table_158-Entries_in_a_collection_sort_dictionary.rakumod) [Table 159 – Entries in a page label dictionary](lib/ISO_32000/Table_159-Entries_in_a_page_label_dictionary.rakumod) [Table 162 – Entries in a transition dictionary](lib/ISO_32000/Table_162-Entries_in_a_transition_dictionary.rakumod) [Table 166 – Entries in a border style dictionary](lib/ISO_32000/Table_166-Entries_in_a_border_style_dictionary.rakumod) [Table 167 – Entries in a border effect dictionary](lib/ISO_32000/Table_167-Entries_in_a_border_effect_dictionary.rakumod) [Table 193 – Entries common to all action dictionaries](lib/ISO_32000/Table_193-Entries_common_to_all_action_dictionaries.rakumod) [Table 199 – Additional entries specific to a go-to action](lib/ISO_32000/Table_199-Additional_entries_specific_to_a_go-to_action.rakumod) [Table 200 – Additional entries specific to a remote go-to action](lib/ISO_32000/Table_200-Additional_entries_specific_to_a_remote_go-to_action.rakumod) [Table 201 – Additional entries specific to an embedded go-to action](lib/ISO_32000/Table_201-Additional_entries_specific_to_an_embedded_go-to_action.rakumod) [Table 203 – Additional entries specific to a launch action](lib/ISO_32000/Table_203-Additional_entries_specific_to_a_launch_action.rakumod) [Table 205 – Additional entries specific to a thread action](lib/ISO_32000/Table_205-Additional_entries_specific_to_a_thread_action.rakumod) [Table 206 – Additional entries specific to a URI action](lib/ISO_32000/Table_206-Additional_entries_specific_to_a_URI_action.rakumod) [Table 208 – Additional entries specific to a sound action](lib/ISO_32000/Table_208-Additional_entries_specific_to_a_sound_action.rakumod) [Table 209 – Additional entries specific to a movie action](lib/ISO_32000/Table_209-Additional_entries_specific_to_a_movie_action.rakumod) [Table 210 – Additional entries specific to a hide action](lib/ISO_32000/Table_210-Additional_entries_specific_to_a_hide_action.rakumod) [Table 212 – Additional entries specific to named actions](lib/ISO_32000/Table_212-Additional_entries_specific_to_named_actions.rakumod) [Table 213 – Additional entries specific to a set-OCG-state action](lib/ISO_32000/Table_213-Additional_entries_specific_to_a_set-OCG-state_action.rakumod) [Table 214 – Additional entries specific to a rendition action](lib/ISO_32000/Table_214-Additional_entries_specific_to_a_rendition_action.rakumod) [Table 215 – Additional entries specific to a transition action](lib/ISO_32000/Table_215-Additional_entries_specific_to_a_transition_action.rakumod) [Table 216 – Additional entries specific to a go-to-3D-view action](lib/ISO_32000/Table_216-Additional_entries_specific_to_a_go-to-ThreeD-view_action.rakumod) [Table 217 – Additional entries specific to a JavaScript action](lib/ISO_32000/Table_217-Additional_entries_specific_to_a_JavaScript_action.rakumod) [Table 236 – Additional entries specific to a submit-form action](lib/ISO_32000/Table_236-Additional_entries_specific_to_a_submit-form_action.rakumod) [Table 238 – Additional entries specific to a reset-form action](lib/ISO_32000/Table_238-Additional_entries_specific_to_a_reset-form_action.rakumod) [Table 240 – Additional entries specific to an import-data action](lib/ISO_32000/Table_240-Additional_entries_specific_to_an_import-data_action.rakumod) [Table 247 – Entries in an icon fit dictionary](lib/ISO_32000/Table_247-Entries_in_an_icon_fit_dictionary.rakumod) [Table 262 – Additional entries in a rectilinear measure dictionary](lib/ISO_32000/Table_262-Additional_entries_in_a_rectilinear_measure_dictionary.rakumod) [Table 264 – Entries common to all requirement dictionaries](lib/ISO_32000/Table_264-Entries_common_to_all_requirement_dictionaries.rakumod) [Table 265 – Entries in a requirement handler dictionary](lib/ISO_32000/Table_265-Entries_in_a_requirement_handler_dictionary.rakumod) [Table 266 – Entries common to all rendition dictionaries](lib/ISO_32000/Table_266-Entries_common_to_all_rendition_dictionaries.rakumod) [Table 268 – Entries in a media criteria dictionary](lib/ISO_32000/Table_268-Entries_in_a_media_criteria_dictionary.rakumod) [Table 273 – Entries common to all media clip dictionaries](lib/ISO_32000/Table_273-Entries_common_to_all_media_clip_dictionaries.rakumod) [Table 281 – Entries in a media duration dictionary](lib/ISO_32000/Table_281-Entries_in_a_media_duration_dictionary.rakumod) [Table 285 – Entries common to all media offset dictionaries](lib/ISO_32000/Table_285-Entries_common_to_all_media_offset_dictionaries.rakumod) [Table 289 – Entries in a timespan dictionary](lib/ISO_32000/Table_289-Entries_in_a_timespan_dictionary.rakumod) [Table 323 – Entries in a structure element dictionary](lib/ISO_32000/Table_323-Entries_in_a_structure_element_dictionary.rakumod) [Table 352 – Entries common to all Web Capture content sets](lib/ISO_32000/Table_352-Entries_common_to_all_Web_Capture_content_sets.rakumod) [Table 353 – Additional entries specific to a Web Capture page set](lib/ISO_32000/Table_353-Additional_entries_specific_to_a_Web_Capture_page_set.rakumod) [Table 354 – Additional entries specific to a Web Capture image set](lib/ISO_32000/Table_354-Additional_entries_specific_to_a_Web_Capture_image_set.rakumod) [Table 355 – Entries in a source information dictionary](lib/ISO_32000/Table_355-Entries_in_a_source_information_dictionary.rakumod) [Table 357 – Entries in a Web Capture command dictionary](lib/ISO_32000/Table_357-Entries_in_a_Web_Capture_command_dictionary.rakumod) [Table 361 – Entries in a box style dictionary](lib/ISO_32000/Table_361-Entries_in_a_box_style_dictionary.rakumod) [Table 365 – Entries in an output intent dictionary](lib/ISO_32000/Table_365-Entries_in_an_output_intent_dictionary.rakumod) |
| /SA | [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) [Table 304 – Entries in a 3D view dictionary](lib/ISO_32000/Table_304-Entries_in_a_ThreeD_view_dictionary.rakumod) |
| /SE | [Table 153 – Entries in an outline item dictionary](lib/ISO_32000/Table_153-Entries_in_an_outline_item_dictionary.rakumod) |
| /SI | [Table 352 – Entries common to all Web Capture content sets](lib/ISO_32000/Table_352-Entries_common_to_all_Web_Capture_content_sets.rakumod) |
| /SM | [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) |
| /SMask | [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) [Table 89 – Additional Entries Specific to an Image Dictionary](lib/ISO_32000/Table_89-Additional_Entries_Specific_to_an_Image_Dictionary.rakumod) |
| /SMaskInData | [Table 89 – Additional Entries Specific to an Image Dictionary](lib/ISO_32000/Table_89-Additional_Entries_Specific_to_an_Image_Dictionary.rakumod) |
| /SP | [Table 271 – Additional entries in a media rendition dictionary](lib/ISO_32000/Table_271-Additional_entries_in_a_media_rendition_dictionary.rakumod) |
| /SS | [Table 162 – Entries in a transition dictionary](lib/ISO_32000/Table_162-Entries_in_a_transition_dictionary.rakumod) [Table 263 – Entries in a number format dictionary](lib/ISO_32000/Table_263-Entries_in_a_number_format_dictionary.rakumod) |
| /SV | [Table 232 – Additional entries specific to a signature field](lib/ISO_32000/Table_232-Additional_entries_specific_to_a_signature_field.rakumod) |
| /SW | [Table 247 – Entries in an icon fit dictionary](lib/ISO_32000/Table_247-Entries_in_an_icon_fit_dictionary.rakumod) |
| /Schema | [Table 155 – Entries in a collection dictionary](lib/ISO_32000/Table_155-Entries_in_a_collection_dictionary.rakumod) |
| /Scope | [Table 349 – Standard table attributes](lib/ISO_32000/Table_349-Standard_table_attributes.rakumod) |
| /Script | [Table 265 – Entries in a requirement handler dictionary](lib/ISO_32000/Table_265-Entries_in_a_requirement_handler_dictionary.rakumod) |
| /SeparationColorNames | [Table 367 – Additional entries specific to a trap network appearance stream](lib/ISO_32000/Table_367-Additional_entries_specific_to_a_trap_network_appearance_stream.rakumod) |
| /SeparationInfo | [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) |
| /SetF | [Table 246 – Entries in an FDF field dictionary](lib/ISO_32000/Table_246-Entries_in_an_FDF_field_dictionary.rakumod) |
| /SetFf | [Table 246 – Entries in an FDF field dictionary](lib/ISO_32000/Table_246-Entries_in_an_FDF_field_dictionary.rakumod) |
| /Shading | [Table 33 – Entries in a resource dictionary](lib/ISO_32000/Table_33-Entries_in_a_resource_dictionary.rakumod) [Table 76 – Entries in a Type 2 Pattern Dictionary](lib/ISO_32000/Table_76-Entries_in_a_Type_2_Pattern_Dictionary.rakumod) |
| /ShadingType | [Table 78 – Entries Common to All Shading Dictionaries](lib/ISO_32000/Table_78-Entries_Common_to_All_Shading_Dictionaries.rakumod) |
| /ShowControls | [Table 296 – Entries in a movie activation dictionary](lib/ISO_32000/Table_296-Entries_in_a_movie_activation_dictionary.rakumod) |
| /SigFlags | [Table 218 – Entries in the interactive form dictionary](lib/ISO_32000/Table_218-Entries_in_the_interactive_form_dictionary.rakumod) |
| /Signature | [Table 255 – Entries in the UR transform parameters dictionary](lib/ISO_32000/Table_255-Entries_in_the_UR_transform_parameters_dictionary.rakumod) |
| /Size | [Table 15 – Entries in the file trailer dictionary](lib/ISO_32000/Table_15-Entries_in_the_file_trailer_dictionary.rakumod) [Table 17 – Additional entries specific to a cross-reference stream dictionary](lib/ISO_32000/Table_17-Additional_entries_specific_to_a_cross-reference_stream_dictionary.rakumod) [Table 39 – Additional entries specific to a type 0 function dictionary](lib/ISO_32000/Table_39-Additional_entries_specific_to_a_type_0_function_dictionary.rakumod) [Table 46 – Entries in an embedded file parameter dictionary](lib/ISO_32000/Table_46-Entries_in_an_embedded_file_parameter_dictionary.rakumod) |
| /Solidities | [Table 73 – Entries in a DeviceN Mixing Hints Dictionary](lib/ISO_32000/Table_73-Entries_in_a_DeviceN_Mixing_Hints_Dictionary.rakumod) |
| /Sort | [Table 155 – Entries in a collection dictionary](lib/ISO_32000/Table_155-Entries_in_a_collection_dictionary.rakumod) |
| /Sound | [Table 185 – Additional entries specific to a sound annotation](lib/ISO_32000/Table_185-Additional_entries_specific_to_a_sound_annotation.rakumod) [Table 208 – Additional entries specific to a sound action](lib/ISO_32000/Table_208-Additional_entries_specific_to_a_sound_action.rakumod) |
| /SoundActions | [Table 259 – Entries in a legal attestation dictionary](lib/ISO_32000/Table_259-Entries_in_a_legal_attestation_dictionary.rakumod) |
| /SpaceAfter | [Table 344 – Additional standard layout attributes specific to block-level structure elements](lib/ISO_32000/Table_344-Additional_standard_layout_attributes_specific_to_block-level_structure_elements.rakumod) |
| /SpaceBefore | [Table 344 – Additional standard layout attributes specific to block-level structure elements](lib/ISO_32000/Table_344-Additional_standard_layout_attributes_specific_to_block-level_structure_elements.rakumod) |
| /SpiderInfo | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) |
| /SpotFunction | [Table 130 – Entries in a type 1 halftone dictionary](lib/ISO_32000/Table_130-Entries_in_a_type_1_halftone_dictionary.rakumod) |
| /St | [Table 159 – Entries in a page label dictionary](lib/ISO_32000/Table_159-Entries_in_a_page_label_dictionary.rakumod) |
| /Start | [Table 296 – Entries in a movie activation dictionary](lib/ISO_32000/Table_296-Entries_in_a_movie_activation_dictionary.rakumod) |
| /StartIndent | [Table 344 – Additional standard layout attributes specific to block-level structure elements](lib/ISO_32000/Table_344-Additional_standard_layout_attributes_specific_to_block-level_structure_elements.rakumod) |
| /StartResource | [Table 297 – Entries in a slideshow dictionary](lib/ISO_32000/Table_297-Entries_in_a_slideshow_dictionary.rakumod) |
| /State | [Table 172 – Additional entries specific to a text annotation](lib/ISO_32000/Table_172-Additional_entries_specific_to_a_text_annotation.rakumod) [Table 213 – Additional entries specific to a set-OCG-state action](lib/ISO_32000/Table_213-Additional_entries_specific_to_a_set-OCG-state_action.rakumod) |
| /StateModel | [Table 172 – Additional entries specific to a text annotation](lib/ISO_32000/Table_172-Additional_entries_specific_to_a_text_annotation.rakumod) |
| /Status | [Table 243 – Entries in the FDF dictionary](lib/ISO_32000/Table_243-Entries_in_the_FDF_dictionary.rakumod) |
| /StemH | [Table 122 – Entries common to all font descriptors](lib/ISO_32000/Table_122-Entries_common_to_all_font_descriptors.rakumod) |
| /StemV | [Table 122 – Entries common to all font descriptors](lib/ISO_32000/Table_122-Entries_common_to_all_font_descriptors.rakumod) |
| /Stm | [Table 324 – Entries in a marked-content reference dictionary](lib/ISO_32000/Table_324-Entries_in_a_marked-content_reference_dictionary.rakumod) |
| /StmF | [Table 20 – Entries common to all encryption dictionaries](lib/ISO_32000/Table_20-Entries_common_to_all_encryption_dictionaries.rakumod) |
| /StmOwn | [Table 324 – Entries in a marked-content reference dictionary](lib/ISO_32000/Table_324-Entries_in_a_marked-content_reference_dictionary.rakumod) |
| /StrF | [Table 20 – Entries common to all encryption dictionaries](lib/ISO_32000/Table_20-Entries_common_to_all_encryption_dictionaries.rakumod) |
| /StructParent | [Table 89 – Additional Entries Specific to an Image Dictionary](lib/ISO_32000/Table_89-Additional_Entries_Specific_to_an_Image_Dictionary.rakumod) [Table 95 – Additional Entries Specific to a Type 1 Form Dictionary](lib/ISO_32000/Table_95-Additional_Entries_Specific_to_a_Type_1_Form_Dictionary.rakumod) [Table 164 – Entries common to all annotation dictionaries](lib/ISO_32000/Table_164-Entries_common_to_all_annotation_dictionaries.rakumod) [Table 326 – Additional dictionary entries for structure element access](lib/ISO_32000/Table_326-Additional_dictionary_entries_for_structure_element_access.rakumod) |
| /StructParents | [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) [Table 95 – Additional Entries Specific to a Type 1 Form Dictionary](lib/ISO_32000/Table_95-Additional_Entries_Specific_to_a_Type_1_Form_Dictionary.rakumod) [Table 326 – Additional dictionary entries for structure element access](lib/ISO_32000/Table_326-Additional_dictionary_entries_for_structure_element_access.rakumod) |
| /StructTreeRoot | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) |
| /Style | [Table 124 – Additional font descriptor entries for CIDFonts](lib/ISO_32000/Table_124-Additional_font_descriptor_entries_for_CIDFonts.rakumod) |
| /SubFilter | [Table 20 – Entries common to all encryption dictionaries](lib/ISO_32000/Table_20-Entries_common_to_all_encryption_dictionaries.rakumod) [Table 234 – Entries in a signature field seed value dictionary](lib/ISO_32000/Table_234-Entries_in_a_signature_field_seed_value_dictionary.rakumod) [Table 252 – Entries in a signature dictionary](lib/ISO_32000/Table_252-Entries_in_a_signature_dictionary.rakumod) |
| /Subj | [Table 170 – Additional entries specific to markup annotations](lib/ISO_32000/Table_170-Additional_entries_specific_to_markup_annotations.rakumod) |
| /Subject | [Table 235 – Entries in a certificate seed value dictionary](lib/ISO_32000/Table_235-Entries_in_a_certificate_seed_value_dictionary.rakumod) [Table 317 – Entries in the document information dictionary](lib/ISO_32000/Table_317-Entries_in_the_document_information_dictionary.rakumod) |
| /SubjectDN | [Table 235 – Entries in a certificate seed value dictionary](lib/ISO_32000/Table_235-Entries_in_a_certificate_seed_value_dictionary.rakumod) |
| /Subtype | [Table 45 – Additional entries in an embedded file stream dictionary](lib/ISO_32000/Table_45-Additional_entries_in_an_embedded_file_stream_dictionary.rakumod) [Table 47 – Entries in a Mac OS file information dictionary](lib/ISO_32000/Table_47-Entries_in_a_Mac_OS_file_information_dictionary.rakumod) [Table 71 – Entries in a DeviceN Colour Space Attributes Dictionary](lib/ISO_32000/Table_71-Entries_in_a_DeviceN_Colour_Space_Attributes_Dictionary.rakumod) [Table 88 – Additional Entries Specific to a PostScript XObject Dictionary](lib/ISO_32000/Table_88-Additional_Entries_Specific_to_a_PostScript_XObject_Dictionary.rakumod) [Table 89 – Additional Entries Specific to an Image Dictionary](lib/ISO_32000/Table_89-Additional_Entries_Specific_to_an_Image_Dictionary.rakumod) [Table 95 – Additional Entries Specific to a Type 1 Form Dictionary](lib/ISO_32000/Table_95-Additional_Entries_Specific_to_a_Type_1_Form_Dictionary.rakumod) [Table 111 – Entries in a Type 1 font dictionary](lib/ISO_32000/Table_111-Entries_in_a_Type_1_font_dictionary.rakumod) [Table 112 – Entries in a Type 3 font dictionary](lib/ISO_32000/Table_112-Entries_in_a_Type_3_font_dictionary.rakumod) [Table 117 – Entries in a CIDFont dictionary](lib/ISO_32000/Table_117-Entries_in_a_CIDFont_dictionary.rakumod) [Table 121 – Entries in a Type 0 font dictionary](lib/ISO_32000/Table_121-Entries_in_a_Type_0_font_dictionary.rakumod) [Table 127 – Additional entries in an embedded font stream dictionary](lib/ISO_32000/Table_127-Additional_entries_in_an_embedded_font_stream_dictionary.rakumod) [Table 157 – Entries in a collection field dictionary](lib/ISO_32000/Table_157-Entries_in_a_collection_field_dictionary.rakumod) [Table 164 – Entries common to all annotation dictionaries](lib/ISO_32000/Table_164-Entries_common_to_all_annotation_dictionaries.rakumod) [Table 172 – Additional entries specific to a text annotation](lib/ISO_32000/Table_172-Additional_entries_specific_to_a_text_annotation.rakumod |
## dist_zef-dwarring-PDF-ISO_32000.md
## Chunk 9 of 10
) [Table 173 – Additional entries specific to a link annotation](lib/ISO_32000/Table_173-Additional_entries_specific_to_a_link_annotation.rakumod) [Table 174 – Additional entries specific to a free text annotation](lib/ISO_32000/Table_174-Additional_entries_specific_to_a_free_text_annotation.rakumod) [Table 175 – Additional entries specific to a line annotation](lib/ISO_32000/Table_175-Additional_entries_specific_to_a_line_annotation.rakumod) [Table 177 – Additional entries specific to a square or circle annotation](lib/ISO_32000/Table_177-Additional_entries_specific_to_a_square_or_circle_annotation.rakumod) [Table 178 – Additional entries specific to a polygon or polyline annotation](lib/ISO_32000/Table_178-Additional_entries_specific_to_a_polygon_or_polyline_annotation.rakumod) [Table 179 – Additional entries specific to text markup annotations](lib/ISO_32000/Table_179-Additional_entries_specific_to_text_markup_annotations.rakumod) [Table 180 – Additional entries specific to a caret annotation](lib/ISO_32000/Table_180-Additional_entries_specific_to_a_caret_annotation.rakumod) [Table 181 – Additional entries specific to a rubber stamp annotation](lib/ISO_32000/Table_181-Additional_entries_specific_to_a_rubber_stamp_annotation.rakumod) [Table 182 – Additional entries specific to an ink annotation](lib/ISO_32000/Table_182-Additional_entries_specific_to_an_ink_annotation.rakumod) [Table 183 – Additional entries specific to a pop-up annotation](lib/ISO_32000/Table_183-Additional_entries_specific_to_a_pop-up_annotation.rakumod) [Table 184 – Additional entries specific to a file attachment annotation](lib/ISO_32000/Table_184-Additional_entries_specific_to_a_file_attachment_annotation.rakumod) [Table 185 – Additional entries specific to a sound annotation](lib/ISO_32000/Table_185-Additional_entries_specific_to_a_sound_annotation.rakumod) [Table 186 – Additional entries specific to a movie annotation](lib/ISO_32000/Table_186-Additional_entries_specific_to_a_movie_annotation.rakumod) [Table 187 – Additional entries specific to a screen annotation](lib/ISO_32000/Table_187-Additional_entries_specific_to_a_screen_annotation.rakumod) [Table 188 – Additional entries specific to a widget annotation](lib/ISO_32000/Table_188-Additional_entries_specific_to_a_widget_annotation.rakumod) [Table 190 – Additional entries specific to a watermark annotation](lib/ISO_32000/Table_190-Additional_entries_specific_to_a_watermark_annotation.rakumod) [Table 192 – Additional entries specific to a redaction annotation](lib/ISO_32000/Table_192-Additional_entries_specific_to_a_redaction_annotation.rakumod) [Table 261 – Entries in a measure dictionary](lib/ISO_32000/Table_261-Entries_in_a_measure_dictionary.rakumod) [Table 297 – Entries in a slideshow dictionary](lib/ISO_32000/Table_297-Entries_in_a_slideshow_dictionary.rakumod) [Table 298 – Additional entries specific to a 3D annotation](lib/ISO_32000/Table_298-Additional_entries_specific_to_a_ThreeD_annotation.rakumod) [Table 300 – Entries in a 3D stream dictionary](lib/ISO_32000/Table_300-Entries_in_a_ThreeD_stream_dictionary.rakumod) [Table 301 – Entries in an 3D animation style dictionary](lib/ISO_32000/Table_301-Entries_in_an_ThreeD_animation_style_dictionary.rakumod) [Table 305 – Entries in a projection dictionary](lib/ISO_32000/Table_305-Entries_in_a_projection_dictionary.rakumod) [Table 306 – Entries in a 3D background dictionary](lib/ISO_32000/Table_306-Entries_in_a_ThreeD_background_dictionary.rakumod) [Table 307 – Entries in a render mode dictionary](lib/ISO_32000/Table_307-Entries_in_a_render_mode_dictionary.rakumod) [Table 309 – Entries in a 3D lighting scheme dictionary](lib/ISO_32000/Table_309-Entries_in_a_ThreeD_lighting_scheme_dictionary.rakumod) [Table 313 – Entries in an external data dictionary used to markup 3D annotations](lib/ISO_32000/Table_313-Entries_in_an_external_data_dictionary_used_to_markup_ThreeD_annotations.rakumod) [Table 315 – Additional entries in a metadata stream dictionary](lib/ISO_32000/Table_315-Additional_entries_in_a_metadata_stream_dictionary.rakumod) [Table 330 – Property list entries for artifacts](lib/ISO_32000/Table_330-Property_list_entries_for_artifacts.rakumod) [Table 362 – Additional entries specific to a printer’s mark annotation](lib/ISO_32000/Table_362-Additional_entries_specific_to_a_printers_mark_annotation.rakumod) [Table 366 – Additional entries specific to a trap network annotation](lib/ISO_32000/Table_366-Additional_entries_specific_to_a_trap_network_annotation.rakumod) |
| /Summary | [Table 349 – Standard table attributes](lib/ISO_32000/Table_349-Standard_table_attributes.rakumod) |
| /Supplement | [Table 116 – Entries in a CIDSystemInfo dictionary](lib/ISO_32000/Table_116-Entries_in_a_CIDSystemInfo_dictionary.rakumod) |
| /Suspects | [Table 321 – Entries in the mark information dictionary](lib/ISO_32000/Table_321-Entries_in_the_mark_information_dictionary.rakumod) |
| /Sy | [Table 180 – Additional entries specific to a caret annotation](lib/ISO_32000/Table_180-Additional_entries_specific_to_a_caret_annotation.rakumod) |
| /Synchronous | [Table 208 – Additional entries specific to a sound action](lib/ISO_32000/Table_208-Additional_entries_specific_to_a_sound_action.rakumod) [Table 296 – Entries in a movie activation dictionary](lib/ISO_32000/Table_296-Entries_in_a_movie_activation_dictionary.rakumod) |
| /T | [Table F.1 – Entries in the linearization parameter dictionary](lib/ISO_32000/Table_F1-Entries_in_the_linearization_parameter_dictionary.rakumod) [Table 161 – Entries in a bead dictionary](lib/ISO_32000/Table_161-Entries_in_a_bead_dictionary.rakumod) [Table 170 – Additional entries specific to markup annotations](lib/ISO_32000/Table_170-Additional_entries_specific_to_markup_annotations.rakumod) [Table 186 – Additional entries specific to a movie annotation](lib/ISO_32000/Table_186-Additional_entries_specific_to_a_movie_annotation.rakumod) [Table 187 – Additional entries specific to a screen annotation](lib/ISO_32000/Table_187-Additional_entries_specific_to_a_screen_annotation.rakumod) [Table 201 – Additional entries specific to an embedded go-to action](lib/ISO_32000/Table_201-Additional_entries_specific_to_an_embedded_go-to_action.rakumod) [Table 202 – Entries specific to a target dictionary](lib/ISO_32000/Table_202-Entries_specific_to_a_target_dictionary.rakumod) [Table 209 – Additional entries specific to a movie action](lib/ISO_32000/Table_209-Additional_entries_specific_to_a_movie_action.rakumod) [Table 210 – Additional entries specific to a hide action](lib/ISO_32000/Table_210-Additional_entries_specific_to_a_hide_action.rakumod) [Table 220 – Entries common to all field dictionaries](lib/ISO_32000/Table_220-Entries_common_to_all_field_dictionaries.rakumod) [Table 246 – Entries in an FDF field dictionary](lib/ISO_32000/Table_246-Entries_in_an_FDF_field_dictionary.rakumod) [Table 262 – Additional entries in a rectilinear measure dictionary](lib/ISO_32000/Table_262-Additional_entries_in_a_rectilinear_measure_dictionary.rakumod) [Table 281 – Entries in a media duration dictionary](lib/ISO_32000/Table_281-Entries_in_a_media_duration_dictionary.rakumod) [Table 284 – Entries in a floating window parameters dictionary](lib/ISO_32000/Table_284-Entries_in_a_floating_window_parameters_dictionary.rakumod) [Table 286 – Additional entries in a media offset time dictionary](lib/ISO_32000/Table_286-Additional_entries_in_a_media_offset_time_dictionary.rakumod) [Table 323 – Entries in a structure element dictionary](lib/ISO_32000/Table_323-Entries_in_a_structure_element_dictionary.rakumod) [Table 353 – Additional entries specific to a Web Capture page set](lib/ISO_32000/Table_353-Additional_entries_specific_to_a_Web_Capture_page_set.rakumod) |
| /TA | [Table 216 – Additional entries specific to a go-to-3D-view action](lib/ISO_32000/Table_216-Additional_entries_specific_to_a_go-to-ThreeD-view_action.rakumod) |
| /TB | [Table 299 – Entries in a 3D activation dictionary](lib/ISO_32000/Table_299-Entries_in_a_ThreeD_activation_dictionary.rakumod) |
| /TBorderStyle | [Table 344 – Additional standard layout attributes specific to block-level structure elements](lib/ISO_32000/Table_344-Additional_standard_layout_attributes_specific_to_block-level_structure_elements.rakumod) |
| /TF | [Table 275 – Entries in a media permissions dictionary](lib/ISO_32000/Table_275-Entries_in_a_media_permissions_dictionary.rakumod) |
| /TI | [Table 231 – Additional entries specific to a choice field](lib/ISO_32000/Table_231-Additional_entries_specific_to_a_choice_field.rakumod) |
| /TID | [Table 353 – Additional entries specific to a Web Capture page set](lib/ISO_32000/Table_353-Additional_entries_specific_to_a_Web_Capture_page_set.rakumod) |
| /TK | [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) |
| /TM | [Table 220 – Entries common to all field dictionaries](lib/ISO_32000/Table_220-Entries_common_to_all_field_dictionaries.rakumod) [Table 301 – Entries in an 3D animation style dictionary](lib/ISO_32000/Table_301-Entries_in_an_ThreeD_animation_style_dictionary.rakumod) |
| /TP | [Table 189 – Entries in an appearance characteristics dictionary](lib/ISO_32000/Table_189-Entries_in_an_appearance_characteristics_dictionary.rakumod) |
| /TPadding | [Table 344 – Additional standard layout attributes specific to block-level structure elements](lib/ISO_32000/Table_344-Additional_standard_layout_attributes_specific_to_block-level_structure_elements.rakumod) |
| /TR | [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) [Table 144 – Entries in a soft-mask dictionary](lib/ISO_32000/Table_144-Entries_in_a_soft-mask_dictionary.rakumod) |
| /TR2 | [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) |
| /TRef | [Table 249 – Entries in an FDF template dictionary](lib/ISO_32000/Table_249-Entries_in_an_FDF_template_dictionary.rakumod) |
| /TS | [Table 352 – Entries common to all Web Capture content sets](lib/ISO_32000/Table_352-Entries_common_to_all_Web_Capture_content_sets.rakumod) [Table 355 – Entries in a source information dictionary](lib/ISO_32000/Table_355-Entries_in_a_source_information_dictionary.rakumod) |
| /TT | [Table 284 – Entries in a floating window parameters dictionary](lib/ISO_32000/Table_284-Entries_in_a_floating_window_parameters_dictionary.rakumod) |
| /TU | [Table 220 – Entries common to all field dictionaries](lib/ISO_32000/Table_220-Entries_common_to_all_field_dictionaries.rakumod) |
| /Tabs | [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) |
| /Target | [Table 243 – Entries in the FDF dictionary](lib/ISO_32000/Table_243-Entries_in_the_FDF_dictionary.rakumod) |
| /TemplateInstantiated | [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) |
| /Templates | [Table 31 – Entries in the name dictionary](lib/ISO_32000/Table_31-Entries_in_the_name_dictionary.rakumod) [Table 248 – Entries in an FDF page dictionary](lib/ISO_32000/Table_248-Entries_in_an_FDF_page_dictionary.rakumod) |
| /TextAlign | [Table 344 – Additional standard layout attributes specific to block-level structure elements](lib/ISO_32000/Table_344-Additional_standard_layout_attributes_specific_to_block-level_structure_elements.rakumod) |
| /TextDecorationColor | [Table 345 – Standard layout attributes specific to inline-level structure elements](lib/ISO_32000/Table_345-Standard_layout_attributes_specific_to_inline-level_structure_elements.rakumod) |
| /TextDecorationThickness | [Table 345 – Standard layout attributes specific to inline-level structure elements](lib/ISO_32000/Table_345-Standard_layout_attributes_specific_to_inline-level_structure_elements.rakumod) |
| /TextDecorationType | [Table 345 – Standard layout attributes specific to inline-level structure elements](lib/ISO_32000/Table_345-Standard_layout_attributes_specific_to_inline-level_structure_elements.rakumod) |
| /TextIndent | [Table 344 – Additional standard layout attributes specific to block-level structure elements](lib/ISO_32000/Table_344-Additional_standard_layout_attributes_specific_to_block-level_structure_elements.rakumod) |
| /Threads | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) |
| /Thumb | [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) |
| /TilingType | [Table 75 – Additional Entries Specific to a Type 1 Pattern Dictionary](lib/ISO_32000/Table_75-Additional_Entries_Specific_to_a_Type_1_Pattern_Dictionary.rakumod) |
| /TimeStamp | [Table 234 – Entries in a signature field seed value dictionary](lib/ISO_32000/Table_234-Entries_in_a_signature_field_seed_value_dictionary.rakumod) |
| /Title | [Table 153 – Entries in an outline item dictionary](lib/ISO_32000/Table_153-Entries_in_an_outline_item_dictionary.rakumod) [Table 317 – Entries in the document information dictionary](lib/ISO_32000/Table_317-Entries_in_the_document_information_dictionary.rakumod) |
| /ToUnicode | [Table 111 – Entries in a Type 1 font dictionary](lib/ISO_32000/Table_111-Entries_in_a_Type_1_font_dictionary.rakumod) [Table 112 – Entries in a Type 3 font dictionary](lib/ISO_32000/Table_112-Entries_in_a_Type_3_font_dictionary.rakumod) [Table 121 – Entries in a Type 0 font dictionary](lib/ISO_32000/Table_121-Entries_in_a_Type_0_font_dictionary.rakumod) |
| /Trans | [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) [Table 215 – Additional entries specific to a transition action](lib/ISO_32000/Table_215-Additional_entries_specific_to_a_transition_action.rakumod) |
| /TransferFunction | [Table 130 – Entries in a type 1 halftone dictionary](lib/ISO_32000/Table_130-Entries_in_a_type_1_halftone_dictionary.rakumod) [Table 131 – Additional entries specific to a type 6 halftone dictionary](lib/ISO_32000/Table_131-Additional_entries_specific_to_a_type_6_halftone_dictionary.rakumod) [Table 132 – Additional entries specific to a type 10 halftone dictionary](lib/ISO_32000/Table_132-Additional_entries_specific_to_a_type_10_halftone_dictionary.rakumod) [Table 133 – Additional entries specific to a type 16 halftone dictionary](lib/ISO_32000/Table_133-Additional_entries_specific_to_a_type_16_halftone_dictionary.rakumod) |
| /TransformMethod | [Table 253 – Entries in a signature reference dictionary](lib/ISO_32000/Table_253-Entries_in_a_signature_reference_dictionary.rakumod) |
| /TransformParams | [Table 253 – Entries in a signature reference dictionary](lib/ISO_32000/Table_253-Entries_in_a_signature_reference_dictionary.rakumod) |
| /TrapRegions | [Table 367 – Additional entries specific to a trap network appearance stream](lib/ISO_32000/Table_367-Additional_entries_specific_to_a_trap_network_appearance_stream.rakumod) |
| /TrapStyles | [Table 367 – Additional entries specific to a trap network appearance stream](lib/ISO_32000/Table_367-Additional_entries_specific_to_a_trap_network_appearance_stream.rakumod) |
| /Trapped | [Table 317 – Entries in the document information dictionary](lib/ISO_32000/Table_317-Entries_in_the_document_information_dictionary.rakumod) |
| /TrimBox | [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) [Table 360 – Entries in a box colour information dictionary](lib/ISO_32000/Table_360-Entries_in_a_box_colour_information_dictionary.rakumod) |
| /TrueTypeFonts | [Table 259 – Entries in a legal attestation dictionary](lib/ISO_32000/Table_259-Entries_in_a_legal_attestation_dictionary.rakumod) |
| /Type | [Table 14 – Optional parameters for Crypt filters](lib/ISO_32000/Table_14-Optional_parameters_for_Crypt_filters.rakumod) [Table 16 – Additional entries specific to an object stream dictionary](lib/ISO_32000/Table_16-Additional_entries_specific_to_an_object_stream_dictionary.rakumod) [Table 17 – Additional entries specific to a cross-reference stream dictionary](lib/ISO_32000/Table_17-Additional_entries_specific_to_a_cross-reference_stream_dictionary.rakumod) [Table 25 – Entries common to all crypt filter dictionaries](lib/ISO_32000/Table_25-Entries_common_to_all_crypt_filter_dictionaries.rakumod) [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) [Table 29 – Required entries in a page tree node](lib/ISO_32000/Table_29-Required_entries_in_a_page_tree_node.rakumod) [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) [Table 44 – Entries in a file specification dictionary](lib/ISO_32000/Table_44-Entries_in_a_file_specification_dictionary.rakumod) [Table 45 – Additional entries in an embedded file stream dictionary](lib/ISO_32000/Table_45-Additional_entries_in_an_embedded_file_stream_dictionary.rakumod) [Table 48 – Entries in a collection item dictionary](lib/ISO_32000/Table_48-Entries_in_a_collection_item_dictionary.rakumod) [Table 49 – Entries in a collection subitem dictionary](lib/ISO_32000/Table_49-Entries_in_a_collection_subitem_dictionary.rakumod) [Table 50 – Entries in a developer extensions dictionary](lib/ISO_32000/Table_50-Entries_in_a_developer_extensions_dictionary.rakumod) [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) [Table 75 – Additional Entries Specific to a Type 1 Pattern Dictionary](lib/ISO_32000/Table_75-Additional_Entries_Specific_to_a_Type_1_Pattern_Dictionary.rakumod) [Table 76 – Entries in a Type 2 Pattern Dictionary](lib/ISO_32000/Table_76-Entries_in_a_Type_2_Pattern_Dictionary.rakumod) [Table 88 – Additional Entries Specific to a PostScript XObject Dictionary](lib/ISO_32000/Table_88-Additional_Entries_Specific_to_a_PostScript_XObject_Dictionary.rakumod) [Table 89 – Additional Entries Specific to an Image Dictionary](lib/ISO_32000/Table_89-Additional_Entries_Specific_to_an_Image_Dictionary.rakumod) [Table 95 – Additional Entries Specific to a Type 1 Form Dictionary](lib/ISO_32000/Table_95-Additional_Entries_Specific_to_a_Type_1_Form_Dictionary.rakumod) [Table 96 – Entries Common to all Group Attributes Dictionaries](lib/ISO_32000/Table_96-Entries_Common_to_all_Group_Attributes_Dictionaries.rakumod) [Table 98 – Entries in an Optional Content Group Dictionary](lib/ISO_32000/Table_98-Entries_in_an_Optional_Content_Group_Dictionary.rakumod) [Table 99 – Entries in an Optional Content Membership Dictionary](lib/ISO_32000/Table_99-Entries_in_an_Optional_Content_Membership_Dictionary.rakumod) [Table 111 – Entries in a Type 1 font dictionary](lib/ISO_32000/Table_111-Entries_in_a_Type_1_font_dictionary.rakumod) [Table 112 – Entries in a Type 3 font dictionary](lib/ISO_32000/Table_112-Entries_in_a_Type_3_font_dictionary.rakumod) [Table 114 – Entries in an encoding dictionary](lib/ISO_32000/Table_114-Entries_in_an_encoding_dictionary.rakumod) [Table 117 – Entries in a CIDFont dictionary](lib/ISO_32000/Table_117-Entries_in_a_CIDFont_dictionary.rakumod) [Table 120 – Additional entries in a CMap stream dictionary](lib/ISO_32000/Table_120-Additional_entries_in_a_CMap_stream_dictionary.rakumod) [Table 121 – Entries in a Type 0 font dictionary](lib/ISO_32000/Table_121-Entries_in_a_Type_0_font_dictionary.rakumod) [Table 122 – Entries common to all font descriptors](lib/ISO_32000/Table_122-Entries_common_to_all_font_descriptors.rakumod) [Table 130 – Entries in a type 1 halftone dictionary](lib/ISO_32000/Table_130-Entries_in_a_type_1_halftone_dictionary.rakumod) [Table 131 – Additional entries specific to a type 6 halftone dictionary](lib/ISO_32000/Table_131-Additional_entries_specific_to_a_type_6_halftone_dictionary.rakumod) [Table 132 – Additional entries specific to a type 10 halftone dictionary](lib/ISO_32000/Table_132-Additional_entries_specific_to_a_type_10_halftone_dictionary.rakumod) [Table 133 – Additional entries specific to a type 16 halftone dictionary](lib/ISO_32000/Table_133-Additional_entries_specific_to_a_type_16_halftone_dictionary.rakumod) [Table 134 – Entries in a type 5 halftone dictionary](lib/ISO_32000/Table_134-Entries_in_a_type_5_halftone_dictionary.rakumod) [Table 144 – Entries in a soft-mask dictionary](lib/ISO_32000/Table_144-Entries_in_a_soft-mask_dictionary.rakumod) [Table 152 – Entries in the outline dictionary](lib/ISO_32000/Table_152-Entries_in_the_outline_dictionary.rakumod) [Table 155 – Entries in a collection dictionary](lib/ISO_32000/Table_155-Entries_in_a_collection_dictionary.rakumod) [Table 156 – Entries in a collection schema dictionary](lib/ISO_32000/Table_156-Entries_in_a_collection_schema_dictionary.rakumod) [Table 157 – Entries in a collection field dictionary](lib/ISO_32000/Table_157-Entries_in_a_collection_field_dictionary.rakumod) [Table 158 – Entries in a collection sort dictionary](lib/ISO_32000/Table_158-Entries_in_a_collection_sort_dictionary.rakumod) [Table 159 – Entries in a page label dictionary](lib/ISO_32000/Table_159-Entries_in_a_page_label_dictionary.rakumod) [Table 160 – Entries in a thread dictionary](lib/ISO_32000/Table_160-Entries_in_a_thread_dictionary.rakumod) [Table 161 – Entries in a bead dictionary](lib/ISO_32000/Table_161-Entries_in_a_bead_dictionary.rakumod) [Table 162 – Entries in a transition dictionary](lib/ISO_32000/Table_162-Entries_in_a_transition_dictionary.rakumod) [Table 163 – Entries in a navigation node dictionary](lib/ISO_32000/Table_163-Entries_in_a_navigation_node_dictionary.rakumod) [Table 164 – Entries common to all annotation dictionaries](lib/ISO_32000/Table_164-Entries_common_to_all_annotation_dictionaries.rakumod) [Table 166 – Entries in a border style dictionary](lib/ISO_32000/Table_166-Entries_in_a_border_style_dictionary.rakumod) [Table 191 – Entries in a fixed print dictionary](lib/ISO_32000/Table_191-Entries_in_a_fixed_print_dictionary.rakumod) [Table 193 – Entries common to all action dictionaries](lib/ISO_32000/Table_193-Entries_common_to_all_action_dictionaries.rakumod) [Table 233 – Entries in a signature field lock dictionary](lib/ISO_32000/Table_233-Entries_in_a_signature_field_lock_dictionary.rakumod) [Table 234 – Entries in a signature field seed value dictionary](lib/ISO_32000/Table_234-Entries_in_a_signature_field_seed_value_dictionary.rakumod) [Table 235 – Entries in a certificate seed value dictionary](lib/ISO_32000/Table_235-Entries_in_a_certificate_seed_value_dictionary.rakumod) [Table 252 – Entries in a signature dictionary](lib/ISO_32000/Table_252-Entries_in_a_signature_dictionary.rakumod) [Table 253 – Entries in a signature reference dictionary](lib/ISO_32000/Table_253-Entries_in_a_signature_reference_dictionary.rakumod) [Table 254 – Entries in the DocMDP transform parameters dictionary](lib/ISO_32000/Table_254-Entries_in_the_DocMDP_transform_parameters_dictionary.rakumod) [Table 255 – Entries in the UR transform parameters dictionary](lib/ISO_32000/Table_255-Entries_in_the_UR_transform_parameters_dictionary.rakumod) [Table 256 – Entries in the FieldMDP transform parameters dictionary](lib/ISO_32000/Table_256-Entries_in_the_FieldMDP_transform_parameters_dictionary.rakumod) [Table 260 – Entries in a viewport dictionary](lib/ISO_32000/Table_260-Entries_in_a_viewport_dictionary.rakumod) [Table 261 – Entries in a measure dictionary](lib/ISO_32000/Table_261-Entries_in_a_measure_dictionary.rakumod) [Table 263 – Entries in a number format dictionary](lib/ISO_32000/Table_263-Entries_in_a_number_format_dictionary.rakumod) [Table 264 – Entries common to all requirement dictionaries](lib/ISO_32000/Table_264-Entries_common_to_all_requirement_dictionaries.rakumod) [Table 265 – Entries in a requirement handler dictionary](lib/ISO_32000/Table_265-Entries_in_a_requirement_handler_dictionary.rakumod) [Table 266 – Entries common to all rendition dictionaries](lib/ISO_32000/Table_266-Entries_common_to_all_rendition_dictionaries.rakumod) [Table 268 – Entries in a media criteria dictionary](lib/ISO_32000/Table_268-Entries_in_a_media_criteria_dictionary.rakumod) [Table 269 – Entries in a minimum bit depth dictionary](lib/ISO_32000/Table_269-Entries_in_a_minimum_bit_depth_dictionary.rakumod) [Table 270 – Entries in a minimum screen size dictionary](lib/ISO_32000/Table_270-Entries_in_a_minimum_screen_size_dictionary.rakumod) [Table 273 – Entries common to all media clip dictionaries](lib/ISO_32000/Table_273-Entries_common_to_all_media_clip_dictionaries.rakumod) [Table 275 – Entries in a media permissions dictionary](lib/ISO_32000/Table_275-Entries_in_a_media_permissions_dictionary.rakumod) [Table 279 – Entries in a media play parameters dictionary](lib/ISO_32000/Table_279-Entries_in_a_media_play_parameters_dictionary.rakumod) [Table 281 – Entries in a media duration dictionary](lib/ISO_32000/Table_281-Entries_in_a_media_duration_dictionary.rakumod) [Table 282 – Entries in a media screen parameters dictionary](lib/ISO_32000/Table_282-Entries_in_a_media_screen_parameters_dictionary.rakumod) [Table 284 – Entries in a floating window parameters dictionary](lib/ISO_32000/Table_284-Entries_in_a_floating_window_parameters_dictionary.rakumod) [Table 285 – Entries common to all media offset dictionaries](lib/ISO_32000/Table_285-Entries_common_to_all_media_offset_dictionaries.rakumod) [Table 289 – Entries in a timespan dictionary](lib/ISO_32000/Table_289-Entries_in_a_timespan_dictionary.rakumod) [Table 290 – Entries in a media players dictionary](lib/ISO_32000/Table_290-Entries_in_a_media_players_dictionary.rakumod) [Table 291 – Entries in a media player info dictionary](lib/ISO_32000/Table_291-Entries_in_a_media_player_info_dictionary.rakumod) [Table 292 – Entries in a software identifier dictionary](lib/ISO_32000/Table_292-Entries_in_a_software_identifier_dictionary.rakumod) [Table 294 – Additional entries specific to a sound object](lib/ISO_32000/Table_294-Additional_entries_specific_to_a_sound_object.rakumod) [Table 297 – Entries in a slideshow dictionary](lib/ISO_32000/Table_297-Entries_in_a_slideshow_dictionary.rakumod) [Table 300 – Entries in a 3D stream dictionary](lib/ISO_32000/Table_300-Entries_in_a_ThreeD_stream_dictionary.rakumod) [Table 301 – Entries in an 3D animation style dictionary](lib/ISO_32000/Table_ |
## dist_zef-dwarring-PDF-ISO_32000.md
## Chunk 10 of 10
301-Entries_in_an_ThreeD_animation_style_dictionary.rakumod) [Table 303 – Entries in a 3D reference dictionary](lib/ISO_32000/Table_303-Entries_in_a_ThreeD_reference_dictionary.rakumod) [Table 304 – Entries in a 3D view dictionary](lib/ISO_32000/Table_304-Entries_in_a_ThreeD_view_dictionary.rakumod) [Table 306 – Entries in a 3D background dictionary](lib/ISO_32000/Table_306-Entries_in_a_ThreeD_background_dictionary.rakumod) [Table 307 – Entries in a render mode dictionary](lib/ISO_32000/Table_307-Entries_in_a_render_mode_dictionary.rakumod) [Table 309 – Entries in a 3D lighting scheme dictionary](lib/ISO_32000/Table_309-Entries_in_a_ThreeD_lighting_scheme_dictionary.rakumod) [Table 311 – Entries in a 3D cross section dictionary](lib/ISO_32000/Table_311-Entries_in_a_ThreeD_cross_section_dictionary.rakumod) [Table 312 – Entries in a 3D node dictionary](lib/ISO_32000/Table_312-Entries_in_a_ThreeD_node_dictionary.rakumod) [Table 313 – Entries in an external data dictionary used to markup 3D annotations](lib/ISO_32000/Table_313-Entries_in_an_external_data_dictionary_used_to_markup_ThreeD_annotations.rakumod) [Table 315 – Additional entries in a metadata stream dictionary](lib/ISO_32000/Table_315-Additional_entries_in_a_metadata_stream_dictionary.rakumod) [Table 322 – Entries in the structure tree root](lib/ISO_32000/Table_322-Entries_in_the_structure_tree_root.rakumod) [Table 323 – Entries in a structure element dictionary](lib/ISO_32000/Table_323-Entries_in_a_structure_element_dictionary.rakumod) [Table 324 – Entries in a marked-content reference dictionary](lib/ISO_32000/Table_324-Entries_in_a_marked-content_reference_dictionary.rakumod) [Table 325 – Entries in an object reference dictionary](lib/ISO_32000/Table_325-Entries_in_an_object_reference_dictionary.rakumod) [Table 330 – Property list entries for artifacts](lib/ISO_32000/Table_330-Property_list_entries_for_artifacts.rakumod) [Table 352 – Entries common to all Web Capture content sets](lib/ISO_32000/Table_352-Entries_common_to_all_Web_Capture_content_sets.rakumod) [Table 365 – Entries in an output intent dictionary](lib/ISO_32000/Table_365-Entries_in_an_output_intent_dictionary.rakumod) |
| /U | [Table 21 – Additional encryption dictionary entries for the standard security handler](lib/ISO_32000/Table_21-Additional_encryption_dictionary_entries_for_the_standard_security_handler.rakumod) [Table 194 – Entries in an annotation’s additional-actions dictionary](lib/ISO_32000/Table_194-Entries_in_an_annotations_additional-actions_dictionary.rakumod) [Table 263 – Entries in a number format dictionary](lib/ISO_32000/Table_263-Entries_in_a_number_format_dictionary.rakumod) [Table 292 – Entries in a software identifier dictionary](lib/ISO_32000/Table_292-Entries_in_a_software_identifier_dictionary.rakumod) [Table 356 – Entries in a URL alias dictionary](lib/ISO_32000/Table_356-Entries_in_a_URL_alias_dictionary.rakumod) |
| /U3DPath | [Table 304 – Entries in a 3D view dictionary](lib/ISO_32000/Table_304-Entries_in_a_ThreeD_view_dictionary.rakumod) |
| /UC | [Table 284 – Entries in a floating window parameters dictionary](lib/ISO_32000/Table_284-Entries_in_a_floating_window_parameters_dictionary.rakumod) |
| /UCR | [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) |
| /UCR2 | [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) |
| /UF | [Table 44 – Entries in a file specification dictionary](lib/ISO_32000/Table_44-Entries_in_a_file_specification_dictionary.rakumod) |
| /UR3 | [Table 258 – Entries in a permissions dictionary](lib/ISO_32000/Table_258-Entries_in_a_permissions_dictionary.rakumod) |
| /URI | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) [Table 206 – Additional entries specific to a URI action](lib/ISO_32000/Table_206-Additional_entries_specific_to_a_URI_action.rakumod) |
| /URIActions | [Table 259 – Entries in a legal attestation dictionary](lib/ISO_32000/Table_259-Entries_in_a_legal_attestation_dictionary.rakumod) |
| /URL | [Table 235 – Entries in a certificate seed value dictionary](lib/ISO_32000/Table_235-Entries_in_a_certificate_seed_value_dictionary.rakumod) [Table 357 – Entries in a Web Capture command dictionary](lib/ISO_32000/Table_357-Entries_in_a_Web_Capture_command_dictionary.rakumod) |
| /URLS | [Table 31 – Entries in the name dictionary](lib/ISO_32000/Table_31-Entries_in_the_name_dictionary.rakumod) |
| /URLType | [Table 235 – Entries in a certificate seed value dictionary](lib/ISO_32000/Table_235-Entries_in_a_certificate_seed_value_dictionary.rakumod) |
| /Unix | [Table 44 – Entries in a file specification dictionary](lib/ISO_32000/Table_44-Entries_in_a_file_specification_dictionary.rakumod) [Table 203 – Additional entries specific to a launch action](lib/ISO_32000/Table_203-Additional_entries_specific_to_a_launch_action.rakumod) |
| /Usage | [Table 98 – Entries in an Optional Content Group Dictionary](lib/ISO_32000/Table_98-Entries_in_an_Optional_Content_Group_Dictionary.rakumod) |
| /UseCMap | [Table 120 – Additional entries in a CMap stream dictionary](lib/ISO_32000/Table_120-Additional_entries_in_a_CMap_stream_dictionary.rakumod) |
| /User | [Table 102 – Entries in an Optional Content Usage Dictionary](lib/ISO_32000/Table_102-Entries_in_an_Optional_Content_Usage_Dictionary.rakumod) |
| /UserProperties | [Table 321 – Entries in the mark information dictionary](lib/ISO_32000/Table_321-Entries_in_the_mark_information_dictionary.rakumod) |
| /UserUnit | [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) |
| /V | [Table 20 – Entries common to all encryption dictionaries](lib/ISO_32000/Table_20-Entries_common_to_all_encryption_dictionaries.rakumod) [Table 44 – Entries in a file specification dictionary](lib/ISO_32000/Table_44-Entries_in_a_file_specification_dictionary.rakumod) [Table 157 – Entries in a collection field dictionary](lib/ISO_32000/Table_157-Entries_in_a_collection_field_dictionary.rakumod) [Table 161 – Entries in a bead dictionary](lib/ISO_32000/Table_161-Entries_in_a_bead_dictionary.rakumod) [Table 191 – Entries in a fixed print dictionary](lib/ISO_32000/Table_191-Entries_in_a_fixed_print_dictionary.rakumod) [Table 196 – Entries in a form field’s additional-actions dictionary](lib/ISO_32000/Table_196-Entries_in_a_form_fields_additional-actions_dictionary.rakumod) [Table 216 – Additional entries specific to a go-to-3D-view action](lib/ISO_32000/Table_216-Additional_entries_specific_to_a_go-to-ThreeD-view_action.rakumod) [Table 220 – Entries common to all field dictionaries](lib/ISO_32000/Table_220-Entries_common_to_all_field_dictionaries.rakumod) [Table 234 – Entries in a signature field seed value dictionary](lib/ISO_32000/Table_234-Entries_in_a_signature_field_seed_value_dictionary.rakumod) [Table 246 – Entries in an FDF field dictionary](lib/ISO_32000/Table_246-Entries_in_an_FDF_field_dictionary.rakumod) [Table 252 – Entries in a signature dictionary](lib/ISO_32000/Table_252-Entries_in_a_signature_dictionary.rakumod) [Table 254 – Entries in the DocMDP transform parameters dictionary](lib/ISO_32000/Table_254-Entries_in_the_DocMDP_transform_parameters_dictionary.rakumod) [Table 255 – Entries in the UR transform parameters dictionary](lib/ISO_32000/Table_255-Entries_in_the_UR_transform_parameters_dictionary.rakumod) [Table 256 – Entries in the FieldMDP transform parameters dictionary](lib/ISO_32000/Table_256-Entries_in_the_FieldMDP_transform_parameters_dictionary.rakumod) [Table 268 – Entries in a media criteria dictionary](lib/ISO_32000/Table_268-Entries_in_a_media_criteria_dictionary.rakumod) [Table 269 – Entries in a minimum bit depth dictionary](lib/ISO_32000/Table_269-Entries_in_a_minimum_bit_depth_dictionary.rakumod) [Table 270 – Entries in a minimum screen size dictionary](lib/ISO_32000/Table_270-Entries_in_a_minimum_screen_size_dictionary.rakumod) [Table 280 – Entries in a media play parameters MH/BE dictionary](lib/ISO_32000/Table_280-Entries_in_a_media_play_parameters_MH-BE_dictionary.rakumod) [Table 289 – Entries in a timespan dictionary](lib/ISO_32000/Table_289-Entries_in_a_timespan_dictionary.rakumod) [Table 312 – Entries in a 3D node dictionary](lib/ISO_32000/Table_312-Entries_in_a_ThreeD_node_dictionary.rakumod) [Table 329 – Entries in a user property dictionary](lib/ISO_32000/Table_329-Entries_in_a_user_property_dictionary.rakumod) [Table 350 – Entries in the Web Capture information dictionary](lib/ISO_32000/Table_350-Entries_in_the_Web_Capture_information_dictionary.rakumod) |
| /VA | [Table 300 – Entries in a 3D stream dictionary](lib/ISO_32000/Table_300-Entries_in_a_ThreeD_stream_dictionary.rakumod) |
| /VE | [Table 99 – Entries in an Optional Content Membership Dictionary](lib/ISO_32000/Table_99-Entries_in_an_Optional_Content_Membership_Dictionary.rakumod) |
| /VP | [Table 30 – Entries in a page object](lib/ISO_32000/Table_30-Entries_in_a_page_object.rakumod) |
| /Version | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) [Table 242 – Entries in the FDF catalog dictionary](lib/ISO_32000/Table_242-Entries_in_the_FDF_catalog_dictionary.rakumod) [Table 366 – Additional entries specific to a trap network annotation](lib/ISO_32000/Table_366-Additional_entries_specific_to_a_trap_network_annotation.rakumod) |
| /Vertices | [Table 178 – Additional entries specific to a polygon or polyline annotation](lib/ISO_32000/Table_178-Additional_entries_specific_to_a_polygon_or_polyline_annotation.rakumod) |
| /VerticesPerRow | [Table 83 – Additional Entries Specific to a Type 5 Shading Dictionary](lib/ISO_32000/Table_83-Additional_Entries_Specific_to_a_Type_5_Shading_Dictionary.rakumod) |
| /View | [Table 102 – Entries in an Optional Content Usage Dictionary](lib/ISO_32000/Table_102-Entries_in_an_Optional_Content_Usage_Dictionary.rakumod) [Table 155 – Entries in a collection dictionary](lib/ISO_32000/Table_155-Entries_in_a_collection_dictionary.rakumod) |
| /ViewArea | [Table 150 – Entries in a viewer preferences dictionary](lib/ISO_32000/Table_150-Entries_in_a_viewer_preferences_dictionary.rakumod) |
| /ViewClip | [Table 150 – Entries in a viewer preferences dictionary](lib/ISO_32000/Table_150-Entries_in_a_viewer_preferences_dictionary.rakumod) |
| /ViewerPreferences | [Table 28 – Entries in the catalog dictionary](lib/ISO_32000/Table_28-Entries_in_the_catalog_dictionary.rakumod) |
| /Volume | [Table 208 – Additional entries specific to a sound action](lib/ISO_32000/Table_208-Additional_entries_specific_to_a_sound_action.rakumod) [Table 296 – Entries in a movie activation dictionary](lib/ISO_32000/Table_296-Entries_in_a_movie_activation_dictionary.rakumod) |
| /W | [Table 17 – Additional entries specific to a cross-reference stream dictionary](lib/ISO_32000/Table_17-Additional_entries_specific_to_a_cross-reference_stream_dictionary.rakumod) [Table 117 – Entries in a CIDFont dictionary](lib/ISO_32000/Table_117-Entries_in_a_CIDFont_dictionary.rakumod) [Table 166 – Entries in a border style dictionary](lib/ISO_32000/Table_166-Entries_in_a_border_style_dictionary.rakumod) [Table 283 – Entries in a media screen parameters MH/BE dictionary](lib/ISO_32000/Table_283-Entries_in_a_media_screen_parameters_MH-BE_dictionary.rakumod) [Table 361 – Entries in a box style dictionary](lib/ISO_32000/Table_361-Entries_in_a_box_style_dictionary.rakumod) |
| /W2 | [Table 117 – Entries in a CIDFont dictionary](lib/ISO_32000/Table_117-Entries_in_a_CIDFont_dictionary.rakumod) |
| /WC | [Table 197 – Entries in the document catalog’s additional-actions dictionary](lib/ISO_32000/Table_197-Entries_in_the_document_catalogs_additional-actions_dictionary.rakumod) |
| /WMode | [Table 120 – Additional entries in a CMap stream dictionary](lib/ISO_32000/Table_120-Additional_entries_in_a_CMap_stream_dictionary.rakumod) |
| /WP | [Table 197 – Entries in the document catalog’s additional-actions dictionary](lib/ISO_32000/Table_197-Entries_in_the_document_catalogs_additional-actions_dictionary.rakumod) |
| /WS | [Table 197 – Entries in the document catalog’s additional-actions dictionary](lib/ISO_32000/Table_197-Entries_in_the_document_catalogs_additional-actions_dictionary.rakumod) |
| /WhitePoint | [Table 63 – Entries in a CalGray Colour Space Dictionary](lib/ISO_32000/Table_63-Entries_in_a_CalGray_Colour_Space_Dictionary.rakumod) [Table 64 – Entries in a CalRGB Colour Space Dictionary](lib/ISO_32000/Table_64-Entries_in_a_CalRGB_Colour_Space_Dictionary.rakumod) [Table 65 – Entries in a Lab Colour Space Dictionary](lib/ISO_32000/Table_65-Entries_in_a_Lab_Colour_Space_Dictionary.rakumod) |
| /Width | [Table 89 – Additional Entries Specific to an Image Dictionary](lib/ISO_32000/Table_89-Additional_Entries_Specific_to_an_Image_Dictionary.rakumod) [Table 131 – Additional entries specific to a type 6 halftone dictionary](lib/ISO_32000/Table_131-Additional_entries_specific_to_a_type_6_halftone_dictionary.rakumod) [Table 133 – Additional entries specific to a type 16 halftone dictionary](lib/ISO_32000/Table_133-Additional_entries_specific_to_a_type_16_halftone_dictionary.rakumod) [Table 344 – Additional standard layout attributes specific to block-level structure elements](lib/ISO_32000/Table_344-Additional_standard_layout_attributes_specific_to_block-level_structure_elements.rakumod) |
| /Width2 | [Table 133 – Additional entries specific to a type 16 halftone dictionary](lib/ISO_32000/Table_133-Additional_entries_specific_to_a_type_16_halftone_dictionary.rakumod) |
| /Widths | [Table 111 – Entries in a Type 1 font dictionary](lib/ISO_32000/Table_111-Entries_in_a_Type_1_font_dictionary.rakumod) [Table 112 – Entries in a Type 3 font dictionary](lib/ISO_32000/Table_112-Entries_in_a_Type_3_font_dictionary.rakumod) |
| /Win | [Table 203 – Additional entries specific to a launch action](lib/ISO_32000/Table_203-Additional_entries_specific_to_a_launch_action.rakumod) |
| /WritingMode | [Table 343 – Standard layout attributes common to all standard structure types](lib/ISO_32000/Table_343-Standard_layout_attributes_common_to_all_standard_structure_types.rakumod) |
| /X | [Table 194 – Entries in an annotation’s additional-actions dictionary](lib/ISO_32000/Table_194-Entries_in_an_annotations_additional-actions_dictionary.rakumod) [Table 262 – Additional entries in a rectilinear measure dictionary](lib/ISO_32000/Table_262-Additional_entries_in_a_rectilinear_measure_dictionary.rakumod) |
| /XFA | [Table 218 – Entries in the interactive form dictionary](lib/ISO_32000/Table_218-Entries_in_the_interactive_form_dictionary.rakumod) |
| /XHeight | [Table 122 – Entries common to all font descriptors](lib/ISO_32000/Table_122-Entries_common_to_all_font_descriptors.rakumod) |
| /XN | [Table 304 – Entries in a 3D view dictionary](lib/ISO_32000/Table_304-Entries_in_a_ThreeD_view_dictionary.rakumod) |
| /XObject | [Table 33 – Entries in a resource dictionary](lib/ISO_32000/Table_33-Entries_in_a_resource_dictionary.rakumod) |
| /XRefStm | [Table 19 – Additional entries in a hybrid-reference file’s trailer dictionary](lib/ISO_32000/Table_19-Additional_entries_in_a_hybrid-reference_files_trailer_dictionary.rakumod) |
| /XStep | [Table 75 – Additional Entries Specific to a Type 1 Pattern Dictionary](lib/ISO_32000/Table_75-Additional_Entries_Specific_to_a_Type_1_Pattern_Dictionary.rakumod) |
| /Xsquare | [Table 132 – Additional entries specific to a type 10 halftone dictionary](lib/ISO_32000/Table_132-Additional_entries_specific_to_a_type_10_halftone_dictionary.rakumod) |
| /Y | [Table 262 – Additional entries in a rectilinear measure dictionary](lib/ISO_32000/Table_262-Additional_entries_in_a_rectilinear_measure_dictionary.rakumod) |
| /YStep | [Table 75 – Additional Entries Specific to a Type 1 Pattern Dictionary](lib/ISO_32000/Table_75-Additional_Entries_Specific_to_a_Type_1_Pattern_Dictionary.rakumod) |
| /Ysquare | [Table 132 – Additional entries specific to a type 10 halftone dictionary](lib/ISO_32000/Table_132-Additional_entries_specific_to_a_type_10_halftone_dictionary.rakumod) |
| /Z | [Table 268 – Entries in a media criteria dictionary](lib/ISO_32000/Table_268-Entries_in_a_media_criteria_dictionary.rakumod) |
| /Zoom | [Table 102 – Entries in an Optional Content Usage Dictionary](lib/ISO_32000/Table_102-Entries_in_an_Optional_Content_Usage_Dictionary.rakumod) |
| /alphaConstant | [Table 52 – Device-Independent Graphics State Parameters](lib/ISO_32000/Table_52-Device-Independent_Graphics_State_Parameters.rakumod) |
| /alphaSource | [Table 52 – Device-Independent Graphics State Parameters](lib/ISO_32000/Table_52-Device-Independent_Graphics_State_Parameters.rakumod) |
| /blackGeneration | [Table 53 – Device-Dependent Graphics State Parameters](lib/ISO_32000/Table_53-Device-Dependent_Graphics_State_Parameters.rakumod) |
| /blendMode | [Table 52 – Device-Independent Graphics State Parameters](lib/ISO_32000/Table_52-Device-Independent_Graphics_State_Parameters.rakumod) |
| /ca | [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) |
| /checked | [Table 348 – PrintField attributes](lib/ISO_32000/Table_348-PrintField_attributes.rakumod) |
| /clippingPath | [Table 52 – Device-Independent Graphics State Parameters](lib/ISO_32000/Table_52-Device-Independent_Graphics_State_Parameters.rakumod) |
| /color | [Table 52 – Device-Independent Graphics State Parameters](lib/ISO_32000/Table_52-Device-Independent_Graphics_State_Parameters.rakumod) |
| /colorSpace | [Table 52 – Device-Independent Graphics State Parameters](lib/ISO_32000/Table_52-Device-Independent_Graphics_State_Parameters.rakumod) |
| /dashPattern | [Table 52 – Device-Independent Graphics State Parameters](lib/ISO_32000/Table_52-Device-Independent_Graphics_State_Parameters.rakumod) |
| /flatness | [Table 53 – Device-Dependent Graphics State Parameters](lib/ISO_32000/Table_53-Device-Dependent_Graphics_State_Parameters.rakumod) |
| /halftone | [Table 53 – Device-Dependent Graphics State Parameters](lib/ISO_32000/Table_53-Device-Dependent_Graphics_State_Parameters.rakumod) |
| /lineCap | [Table 52 – Device-Independent Graphics State Parameters](lib/ISO_32000/Table_52-Device-Independent_Graphics_State_Parameters.rakumod) |
| /lineJoin | [Table 52 – Device-Independent Graphics State Parameters](lib/ISO_32000/Table_52-Device-Independent_Graphics_State_Parameters.rakumod) |
| /lineWidth | [Table 52 – Device-Independent Graphics State Parameters](lib/ISO_32000/Table_52-Device-Independent_Graphics_State_Parameters.rakumod) |
| /miterLimit | [Table 52 – Device-Independent Graphics State Parameters](lib/ISO_32000/Table_52-Device-Independent_Graphics_State_Parameters.rakumod) |
| /op | [Table 58 – Entries in a Graphics State Parameter Dictionary](lib/ISO_32000/Table_58-Entries_in_a_Graphics_State_Parameter_Dictionary.rakumod) |
| /overprint | [Table 53 – Device-Dependent Graphics State Parameters](lib/ISO_32000/Table_53-Device-Dependent_Graphics_State_Parameters.rakumod) |
| /overprintMode | [Table 53 – Device-Dependent Graphics State Parameters](lib/ISO_32000/Table_53-Device-Dependent_Graphics_State_Parameters.rakumod) |
| /renderingIntent | [Table 52 – Device-Independent Graphics State Parameters](lib/ISO_32000/Table_52-Device-Independent_Graphics_State_Parameters.rakumod) |
| /smoothness | [Table 53 – Device-Dependent Graphics State Parameters](lib/ISO_32000/Table_53-Device-Dependent_Graphics_State_Parameters.rakumod) |
| /softMask | [Table 52 – Device-Independent Graphics State Parameters](lib/ISO_32000/Table_52-Device-Independent_Graphics_State_Parameters.rakumod) |
| /strokeAdjustment | [Table 52 – Device-Independent Graphics State Parameters](lib/ISO_32000/Table_52-Device-Independent_Graphics_State_Parameters.rakumod) |
| /textState | [Table 52 – Device-Independent Graphics State Parameters](lib/ISO_32000/Table_52-Device-Independent_Graphics_State_Parameters.rakumod) |
| /transfer | [Table 53 – Device-Dependent Graphics State Parameters](lib/ISO_32000/Table_53-Device-Dependent_Graphics_State_Parameters.rakumod) |
| /undercolorRemoval | [Table 53 – Device-Dependent Graphics State Parameters](lib/ISO_32000/Table_53-Device-Dependent_Graphics_State_Parameters.rakumod) |
| /versionNumber | [Table 368 – Entry in an OPI version dictionary](lib/ISO_32000/Table_368-Entry_in_an_OPI_version_dictionary.rakumod) |
|
## dist_zef-raku-community-modules-App-InstallerMaker-WiX.md
[](https://github.com/raku-community-modules/App-InstallerMaker-WiX/actions)
# Raku WiX Installer Maker
Written an application in Raku? Want to give Windows users an MSI so they can easily install it? That's what this little program is here to help with.
Fair warning: it does something close to the Simplest Thing That Could Possibly Work, which may or may not meet your needs, and at the time of initial publication (in 2017) has been applied to make an installer for a single application.
* If you have some luck with it, feel free to send a Pull Request to change this description!
Please consider this tool "free as in puppy" - that is, you can freely take it and use it, and if it helps that's great, but you might need to give it some attention along the way. If you make changes that you think are useful to others, feel free to PR them.
## How it works
This tool:
* Builds a private MoarVM, NQP, and Rakudo Raku of the requested version
* Installs a zef (module installer) for use with this
* Uses that to install your application alongside the privately built Rakudo, either from the module ecosystem or from on disk, together with all of its dependencies
* Generates a WiX XML file
* Applies `candle` and `light`, resulting in an MSI
## What this tool does NOT do
* Go to any effort to hide the original source code from anyone curious enough to spend a few minutes hunting inside the install directory
* Compile your code into `exe` / `dll` files
* Handle things that use `Inline::Perl5`, `Inline::Python`, etc. Modules that use native libraries are fine if they're in the set of modules that, when installed on Windows, will grab the required DLL and install it as a resource for the module to use at runtime. Modules that do this include `GTK::Simple`, `Digest::SHA1::Native`, `SSH::LibSSH`, and `Archive::Libarchive`.)
## What you'll need
* Raku, to run this tool
* Git
* Perl, to run the MoarVM/NQP/Rakudo configure programs (tested with ActiveState Perl, though likely shouldn't matter)
* The Visual C++ build tools, and `nmake` / `cl` / `link` on path. Note that this does not imply installing Visual Studio; it is possible to freely download the [standalone compiler](http://landinghub.visualstudio.com/visual-cpp-build-tools). It's probably possible, without too much trouble, to patch this tool to use other compilers.
* [WiX](http://wixtoolset.org/releases/)
## How to use it
Write a YAML configuration file like this:
```
# Versions of MoarVM, NQP, and Rakudo to use. Only 'rakudo' is required,
# and it will then use the same value for NQP and MoarVM. This will work
# except in the case where you want to refer to a commit/branch in the
# Rakudo repository for some reason, since these are actually used to do a
# checkout in the git repositories.
versions:
- moar: 2024.10
- nqp: 2024.10
- rakudo: 2024.10
# The installation target location (currently Raku is not relocatable).
install-location: C:\MyApplication
# The application to install (will be passed to `zef install`), so you can
# actually list multiple things here if you wish.) You can also pass a path
# if the project is not in the Raku module ecosystem.
application: App::MyGloriousApplication
# The name of the MSI file to generate. Optional; default is output.msi.
msi: my-glorious-application.msi
# By default, the PATH will be ammended to include both bin and site bin
# directories, meaning that every binary will be exposed (including the
# bundled MoarVM/Rakudo). This may be useful if you want to make a Raku
# distribution with modules, for example. On the other hand, if you are
# making an installer for an application that just happens to be written in
# Raku, it's not so good. If this `expose-entrypoints` section is included,
# then a folder will be created and added to path, which only contains
# launch scripts for the apps mentioned below (it should match the name of
# the application's entrypoint(s)). Note that you can't include names like
# "perl6" and "moar" in here, only those of scripts installed by the
# application definition above.
expose-entrypoints:
- myapp
# Some WiX configuration. You must generate unique GUIDs for your app. Get
# them [here](https://www.guidgenerator.com/) while supplies last! Check
# the dashes, uppercase, and braces boxes.
wix:
guid: '{YOUR-GUID-HERE}'
name: Your Glorious Application
manufacturer: Your Wonderful Company
version: 6.6.6
language: 1033
component-guid: '{A-DIFFERENT-GUID-HERE}'
```
Then run this application with that YAML file:
```
$ make-raku-wix-installer my-glorious-app.yml
```
All being well, you'll get an MSI file out.
# AUTHOR
Jonathan Worthington
Source can be located at: <https://github.com/raku-community-modules/App-InstallerMaker-WiX> . Comments and Pull Requests are welcome.
# COPYRIGHT AND LICENSE
Copyright 2017 - 2020 Jonathan Worthington
Copyright 2024 Raku Community
This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.
|
## dist_cpan-UFOBAT-StrictClass.md
[](https://travis-ci.org/ufobat/p6-StrictClass)
# NAME
StrictClass - Make your object constructors blow up on unknown attributes
# SYNOPSIS
```
use StrictClass;
class MyClass does StrictClass {
has $.foo;
has $.bar;
}
MyClass.new( :foo(1), :bar(2), :baz('makes you explode'));
```
# DESCRIPTION
Simply using this role for your class makes your `new` "strict". This is a great way to catch small typos.
# AUTHOR
Martin Barth [martin@senfdax.de](mailto:martin@senfdax.de)
# head
THANKS TO
```
* FCO aka SmokeMaschine from #perl6 IRC channel for this code.
* Dave Rolsky for his perl5 module `MooseX::StrictContructor`.
```
# COPYRIGHT AND LICENSE
Copyright 2018 Martin Barth
This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.
|
## new.md
## Chunk 1 of 2
new
Combined from primary sources listed below.
# [In Uni](#___top "go to top of document")[§](#(Uni)_method_new "direct link")
See primary documentation
[in context](/type/Uni#method_new)
for **method new**.
```raku
method new(*@codes --> Uni:D)
```
Creates a new `Uni` instance from the given codepoint numbers.
# [In IO::Socket::INET](#___top "go to top of document")[§](#(IO::Socket::INET)_method_new "direct link")
See primary documentation
[in context](/type/IO/Socket/INET#method_new)
for **method new**.
```raku
multi method new(
:$host,
:$port,
:$family = PF_INET,
:$encoding = 'utf-8',
:$nl-in = "\r\n",
--> IO::Socket::INET:D)
multi method new(
:$localhost,
:$localport,
:$family = PF_INET,
:$listen,
:$encoding = 'utf-8',
:$nl-in = "\r\n",
--> IO::Socket::INET:D)
```
Creates a new socket.
If `:$listen` is True, creates a new socket that listen on `:$localhost` (which can be an IP address or a domain name) on port `:$localport`; in other words the `:$listen` flag determines the *server mode* of the socket. Otherwise (i.e., `:$listen` is `False`), the new socket opens immediately a connection to `:$host` on port `:$port`.
`:$family` defaults to `PF_INET` constant for IPv4, and can be set to `PF_INET6` constant for IPv6.
For text operations (such as [method lines](#method_lines) and [method get](#method_get)), `:$encoding` specifies the encoding, and `:$nl-in` determines the character(s) that separate lines.
# [In Num](#___top "go to top of document")[§](#(Num)_method_new "direct link")
See primary documentation
[in context](/type/Num#method_new)
for **method new**.
```raku
multi method new()
multi method new($n)
```
`Num.new` without argument will create a `Num` with the value `0e0`. With an argument, it will be coerced to `Num` and then returned.
```raku
say Num.new(⅓); # OUTPUT: «0.3333333333333333»
```
# [In role CX::Warn](#___top "go to top of document")[§](#(role_CX::Warn)_method_new "direct link")
See primary documentation
[in context](/type/CX/Warn#method_new)
for **method new**.
`CX::Warn` objects are created when a warning is thrown in any block.
# [In IO::Special](#___top "go to top of document")[§](#(IO::Special)_method_new "direct link")
See primary documentation
[in context](/type/IO/Special#method_new)
for **method new**.
```raku
method new(:$!what!)
```
Takes a single required attribute [what](/routine/what). It is unlikely that you will ever need to construct one of these objects yourself.
# [In Version](#___top "go to top of document")[§](#(Version)_method_new "direct link")
See primary documentation
[in context](/type/Version#method_new)
for **method new**.
```raku
method new(Str:D $s)
```
Creates a `Version` from a string `$s`. The string is combed for the numeric, alphabetic, and wildcard components of the version object. Any characters other than alphanumerics and asterisks are assumed to be equivalent to a dot. A dot is also assumed between any adjacent numeric and alphabetic characters.
# [In Proxy](#___top "go to top of document")[§](#(Proxy)_method_new "direct link")
See primary documentation
[in context](/type/Proxy#method_new)
for **method new**.
```raku
method new(:&FETCH!, :&STORE! --> Proxy:D)
```
Creates a new `Proxy` object. `&FETCH` is called with one argument (the proxy object) when the value is accessed, and must return the value that the fetch produces. `&STORE` is called with two arguments (the proxy object, and the new value) when a new value is stored in the container.
# [In Proc](#___top "go to top of document")[§](#(Proc)_routine_new "direct link")
See primary documentation
[in context](/type/Proc#routine_new)
for **routine new**.
```raku
method new(Proc:U:
:$in = '-',
:$out = '-',
:$err = '-',
Bool :$bin = False,
Bool :$chomp = True,
Bool :$merge = False,
Str:D :$enc = 'UTF-8',
Str:D :$nl = "\n",
--> Proc:D)
sub shell(
$cmd,
:$in = '-',
:$out = '-',
:$err = '-',
Bool :$bin = False,
Bool :$chomp = True,
Bool :$merge = False,
Str:D :$enc = 'UTF-8',
Str:D :$nl = "\n",
:$cwd = $*CWD,
Hash() :$env = %*ENV
--> Proc:D)
```
`new` creates a new `Proc` object, whereas `run` or `shell` create one and spawn it with the command and arguments provided in `@args` or `$cmd`, respectively.
`$in`, `$out` and `$err` are the three standard streams of the to-be-launched program, and default to `"-"` meaning they inherit the stream from the parent process. Setting one (or more) of them to `True` makes the stream available as an [`IO::Pipe`](/type/IO/Pipe) object of the same name, like for example `$proc.out`. You can set them to `False` to discard them. Or you can pass an existing [`IO::Handle`](/type/IO/Handle) object (for example [`IO::Pipe`](/type/IO/Pipe)) in, in which case this handle is used for the stream.
Please bear in mind that the process streams reside in process variables, not in the dynamic variables that make them available to our programs. Thus, modifying [the dynamic filehandle variables (such as `$*OUT`)](/language/variables#Special_filehandles:_STDIN,_STDOUT_and_STDERR) inside the host process will have no effect in the spawned process, unlike `$*CWD` and `$*ENV`, whose changes will be actually reflected in it.
```raku
my $p-name = "/tmp/program.raku";
my $program = Q:to/END/;
#!/usr/bin/env raku
$*OUT.say( qq/\t$*PROGRAM: This goes to standard output/ );
END
spurt $p-name, $program;
$*OUT.put: "1. standard output before doing anything weird";
{
temp $*OUT = open '/tmp/out.txt', :w;
$*OUT.put: "2. temp redefine standard output before this message";
shell( "raku $p-name" ).so;
}
$*OUT.put: "3. everything should be back to normal";
# OUTPUT
# 1. standard output before doing anything weird
# /tmp/program.raku: This goes to standard output
# 3. everything should be back to normal
# /tmp/out.txt will contain:
# 2. temp redefine standard output before this message
```
This program shows that the program spawned with `shell` is not using the temporary `$*OUT` value defined in the host process (redirected to `/tmp/out.txt`), but the initial `STDOUT` defined in the process.
`$bin` controls whether the streams are handled as binary (i.e. [`Blob`](/type/Blob) object) or text (i.e. [`Str`](/type/Str) objects). If `$bin` is False, `$enc` holds the character encoding to encode strings sent to the input stream and decode binary data from the output and error streams.
With `$chomp` set to `True`, newlines are stripped from the output and err streams when reading with `lines` or `get`. `$nl` controls what your idea of a newline is.
If `$merge` is set to True, the standard output and error stream end up merged in `$proc.out`.
# [In IntStr](#___top "go to top of document")[§](#(IntStr)_method_new "direct link")
See primary documentation
[in context](/type/IntStr#method_new)
for **method new**.
```raku
method new(Int $i, Str $s)
```
The constructor requires both the [`Int`](/type/Int) and the [`Str`](/type/Str) value, when constructing one directly the values can be whatever is required:
```raku
my $f = IntStr.new(42, "forty two");
say +$f; # OUTPUT: «42»
say ~$f; # OUTPUT: «"forty two"»
```
# [In RakuAST::Doc::Paragraph](#___top "go to top of document")[§](#(RakuAST::Doc::Paragraph)_method_new "direct link")
See primary documentation
[in context](/type/RakuAST/Doc/Paragraph#method_new)
for **method new**.
```raku
method new(*@atoms)
```
The `new` method must be called to create a new `RakuAST::Doc::Paragraph` object. It takes any number of positional arguments as the atoms of the logical paragraph, where an atom is either a string or a [`RakuAST::Doc::Markup`](/type/RakuAST/Doc/Markup) object.
Typically a `RakuAST::Doc::Paragraph` object is only created if a logical paragraph has at least one markup object.
```raku
my $paragraph = RakuAST::Doc::Paragraph.new(
"Text before ",
RakuAST::Doc::Markup.new(:letter<B>, :atoms("and")),
" after markup\n"
);
```
# [In Seq](#___top "go to top of document")[§](#(Seq)_method_new "direct link")
See primary documentation
[in context](/type/Seq#method_new)
for **method new**.
```raku
proto method new(Seq: |) {*}
multi method new(Seq: Iterator:D $iter)
multi method new(Seq:)
```
Creates a new `Seq` object from the supplied iterator passed as the single argument. Creates an empty `Seq` if called with no argument.
# [In NumStr](#___top "go to top of document")[§](#(NumStr)_method_new "direct link")
See primary documentation
[in context](/type/NumStr#method_new)
for **method new**.
```raku
method new(Num $i, Str $s)
```
The constructor requires both the [`Num`](/type/Num) and the [`Str`](/type/Str) value, when constructing one directly the values can be whatever is required:
```raku
my $f = NumStr.new(42.1e0, "forty two and a bit");
say +$f; # OUTPUT: «42.1»
say ~$f; # OUTPUT: «"forty two and a bit"»
```
# [In Complex](#___top "go to top of document")[§](#(Complex)_method_new "direct link")
See primary documentation
[in context](/type/Complex#method_new)
for **method new**.
```raku
multi method new(Real $re, Real $im --> Complex:D)
```
Creates a new `Complex` object from real and imaginary parts.
```raku
my $complex = Complex.new(1, 1);
say $complex; # OUTPUT: «1+1i»
```
When created without arguments, both parts are considered to be zero.
```raku
say Complex.new; # OUTPUT: «0+0i»
```
# [In Format](#___top "go to top of document")[§](#(Format)_method_new "direct link")
See primary documentation
[in context](/type/Format#method_new)
for **method new**.
```raku
method new($format --> Format:D)
```
Creates a new `Format` object from a `sprintf` compatible format string.
```raku
use v6.e.PREVIEW;
my $d = Format.new("%05d");
say $d; # OUTPUT: «%05d»
say $d(42); # OUTPUT: «00042»
```
# [In RakuAST::Doc::Markup](#___top "go to top of document")[§](#(RakuAST::Doc::Markup)_method_new "direct link")
See primary documentation
[in context](/type/RakuAST/Doc/Markup#method_new)
for **method new**.
```raku
method new(
Str:D :$letter!, # markup identifier, e.g. "B"
Str:D :$opener = "<", # opener marker
Str:D :$closer = ">", # closer marker
:@atoms, # any atoms of this markup
:@meta, # any meta of this markup
)
```
The `new` method can be called to create a new `RakuAST::Doc::Markup` object. It only takes named arguments, with the `:letter` argument being mandatory.
Rakudoc highlighting
```
B<and>
```
```raku
my $markup = RakuAST::Doc::Markup.new(
:letter<B>,
:atoms("and")
);
```
Note that all arguments except `:letter` are optional. So it is possible to create "empty" markup as well.
# [In Map](#___top "go to top of document")[§](#(Map)_method_new "direct link")
See primary documentation
[in context](/type/Map#method_new)
for **method new**.
```raku
method new(*@args)
```
Creates a new Map from a list of alternating keys and values, with [the same semantics](/language/hashmap#Hash_assignment) as described in the [Hashes and maps](/language/hashmap) documentation, but also accepts [`Pair`](/type/Pair)s instead of separate keys and values. Use the [grouping operator](/language/operators#term_(_)) or quote the key to ensure that a literal pair is not interpreted as a named argument.
```raku
my %h = Map.new('a', 1, 'b', 2);
# WRONG: :b(2) interpreted as named argument
say Map.new('a', 1, :b(2)).keys; # OUTPUT: «(a)»
# RIGHT: :b(2) interpreted as Pair because of extra parentheses
say Map.new( ('a', 1, :b(2)) ).keys.sort; # OUTPUT: «(a b)»
# RIGHT: 'b' => 2 always creates a Pair
say Map.new('a', 1, 'b' => 2).keys.sort; # OUTPUT: «(a b)»
```
A shorthand syntax for creating Maps is provided:
```raku
my %h is Map = 'a', 1, 'b', 2;
```
# [In IO::Path::Cygwin](#___top "go to top of document")[§](#(IO::Path::Cygwin)_method_new "direct link")
See primary documentation
[in context](/type/IO/Path/Cygwin#method_new)
for **method new**.
Same as [`IO::Path.new`](/type/IO/Path#method_new), except `:$SPEC` cannot be set and defaults to [`IO::Spec::Cygwin`](/type/IO/Spec/Cygwin), regardless of the operating system the code is being run on.
# [In Metamodel::PackageHOW](#___top "go to top of document")[§](#(Metamodel::PackageHOW)_method_new "direct link")
See primary documentation
[in context](/type/Metamodel/PackageHOW#method_new)
for **method new**.
```raku
method new(*%named)
```
Creates a new `PackageHOW`.
# [In Proc::Async](#___top "go to top of document")[§](#(Proc::Async)_method_new "direct link")
See primary documentation
[in context](/type/Proc/Async#method_new)
for **method new**.
```raku
multi method new(*@ ($path, *@args), :$w, :$enc, :$translate-nl, :$arg0,
:$win-verbatim-args = False,
:$started = False --> Proc::Async:D)
multi method new( :$path, :@args, :$w, :$enc, :$translate-nl, :$arg0,
:$win-verbatim-args = False,
:$started = False --> Proc::Async:D)
```
Creates a new `Proc::Async` object with external program name or path `$path` and the command line arguments `@args`.
If `:w` is passed to `new`, then a pipe to the external program's standard input stream (`stdin`) is opened, to which you can write with `write` and `say`.
The `:enc` specifies [the encoding](/type/IO/Handle#method_encoding) for streams (can still be overridden in individual methods) and defaults to `utf8`.
If `:translate-nl` is set to `True` (default value), OS-specific newline terminators (e.g. `\r\n` on Windows) will be automatically translated to `\n`.
If `:arg0` is set to a value, that value is passed as arg0 to the process instead of the program name.
The `:started` attribute is set by default to `False`, so that you need to start the command afterwards using [`.start`](/type/Proc/Async#method_start). You probably don't want to do this if you want to bind any of the handlers, but it's OK if you just need to start an external program immediately.
On Windows the flag `$win-verbatim-args` disables all automatic quoting of process arguments. See [this blog](https://docs.microsoft.com/en-us/archive/blogs/twistylittlepassagesallalike/everyone-quotes-command-line-arguments-the-wrong-way) for more information on windows command quoting. The flag is ignored on all other platforms. The flag was introduced in Rakudo version 2020.06 and is not present in older releases. By default, it's set to `False`, in which case arguments will be quoted according to Microsoft convention.
# [In IO::Path::Parts](#___top "go to top of document")[§](#(IO::Path::Parts)_method_new "direct link")
See primary documentation
[in context](/type/IO/Path/Parts#method_new)
for **method new**.
```raku
method new(\volume, \dirname, \basename)
```
Create a new `IO::Path::Parts` object with `\volume`, `\dirname` and `\basename` as respectively the volume, directory name and basename parts.
# [In Distribution::Hash](#___top "go to top of document")[§](#(Distribution::Hash)_method_new "direct link")
See primary documentation
[in context](/type/Distribution/Hash#method_new)
for **method new**.
```raku
method new($hash, :$prefix)
```
Creates a new `Distribution::Hash` instance from the metadata contained in `$hash`. All paths in the metadata will be prefixed with `:$prefix`.
# [In Pair](#___top "go to top of document")[§](#(Pair)_method_new "direct link")
See primary documentation
[in context](/type/Pair#method_new)
for **method new**.
```raku
multi method new(Pair: Mu $key, Mu $value)
multi method new(Pair: Mu :$key, Mu :$value)
```
Constructs a new `Pair` object.
# [In RakuAST::Doc::Block](#___top "go to top of document")[§](#(RakuAST::Doc::Block)_method_new "direct link")
See primary documentation
[in context](/type/RakuAST/Doc/Block#method_new)
for **method new**.
```raku
method new(
Str:D :$type!, # type of block, e.g. "head"
Int:D :$level = 0, # level of block, e.g. 1 for "=head1"
:%config, # any configuration to be applied
Str:D :$margin = "", # left margin (0 or more spaces)
:@paragraphs, # paragraphs of this block
Bool:D :$for, # this is a =for block
Bool:D :$abbreviated, # this is an abbreviated block
Bool:D :$directive # this is a directive (also abbreviated)
)
```
The `new` method can be called to create a new `RakuAST::Doc::Block` object. It only takes named arguments, with the `:type` argument being mandatory.
```raku
=begin foo
bar
=end foo
my $block = RakuAST::Doc::Block.new(
:margin(" "),
:type<foo>,
:paragraphs("bar\n",)
);
```
Note that the paragraphs should **not** contain the left margin whitespace.
# [In Distribution::Path](#___top "go to top of document")[§](#(Distribution::Path)_method_new "direct link")
See primary documentation
[in context](/type/Distribution/Path#method_new)
for **method new**.
```raku
method new(IO::Path $prefix, IO::Path :$meta-file = IO::Path)
```
Creates a new `Distribution::Path` instance from the `META6.json` file found at the given `$prefix`, and from which all paths in the metadata will be prefixed with. `:$meta-file` may optionally be passed if a filename other than `META6.json` needs to be used.
# [In Mu](#___top "go to top of document")[§](#(Mu)_method_new "direct link")
See primary documentation
[in context](/type/Mu#method_new)
for **method new**.
```raku
multi method new(*%attrinit)
```
Default method for constructing (create + initialize) new objects of a class. This method expects only named arguments which are then used to initialize attributes with accessors of the same name.
Classes may provide their own `new` method to override this default.
`new` triggers an object construction mechanism that calls submethods named `BUILD` in each class of an inheritance hierarchy, if they exist. See [the documentation on object construction](/language/objects#Object_construction) for more information.
# [In Failure](#___top "go to top of document")[§](#(Failure)_method_new "direct link")
See primary documentation
[in context](/type/Failure#method_new)
for **method new**.
```raku
multi method new(Failure:D:)
multi method new(Failure:U:)
multi method new(Failure:U: Exception:D \exception)
multi method new(Failure:U: $payload)
multi method new(Failure:U: |cap (*@msg))
```
Returns a new `Failure` instance with payload given as argument. If called without arguments on a `Failure` object, it will throw; on a type value, it will create an empty `Failure` with no payload. The latter can be either an [`Exception`](/type/Exception) or a payload for an [`Exception`](/type/Exception). A typical payload would be a [`Str`](/type/Str) with an error message. A list of payloads is also accepted.
```raku
my $e = Failure.new(now.DateTime, 'WELP‼');
say $e;
CATCH{ default { say .^name, ': ', .Str } }
# OUTPUT: «X::AdHoc: 2017-09-10T11:56:05.477237ZWELP‼»
```
# [In Telemetry::Sampler](#___top "go to top of document")[§](#(Telemetry::Sampler)_method_new "direct link")
See primary documentation
[in context](/type/Telemetry/Sampler#method_new)
for **method new**.
```raku
method new(Telemetry::Sampler: @instruments --> Telemetry::Sampler:D)
```
The `new` method takes a list of instruments. If no instruments are specified, then it will look at the `RAKUDO_TELEMETRY_INSTRUMENTS` environment variable to find specification of instruments. If that is not available either, then [`Telemetry::Instrument::Usage`](/type/Telemetry/Instrument/Usage) and [`Telemetry::Instrument::ThreadPool`](/type/Telemetry/Instrument/ThreadPool) will be assumed.
Instruments can be specified by either the type object of the instrument class (e.g. [`Telemetry::Instrument::Usage`](/type/Telemetry/Instrument/Usage)) or by a string, in which case it will be automatically prefixed with "Telemetry::Instrument::", so "Usage" would be the same as [`Telemetry::Instrument::Usage`](/type/Telemetry/Instrument/Usage).
# [In role Blob](#___top "go to top of document")[§](#(role_Blob)_method_new "direct link")
See primary documentation
[in context](/type/Blob#method_new)
for **method new**.
```raku
multi method new(Blob:)
multi method new(Blob: Blob:D $blob)
multi method new(Blob: int @values)
multi method new(Blob: @values)
multi method new(Blob: *@values)
```
Creates an empty `Blob`, or a new `Blob` from another `Blob`, or from a list of integers or values (which will have to be coerced into integers):
```raku
my $blob = Blob.new([1, 2, 3]);
say Blob.new(<1 2 3>); # OUTPUT: «Blob:0x<01 02 03>»
```
# [In IO::CatHandle](#___top "go to top of document")[§](#(IO::CatHandle)_method_new "direct link")
See primary documentation
[in context](/type/IO/CatHandle#method_new)
for **method new**.
```raku
method new(*@handles, :&on-switch, :$chomp = True,
:$nl-in = ["\n", "\r\n"], Str :$encoding, Bool :$bin)
```
Creates a new `IO::CatHandle` object.
The `@handles` positional argument indicates a source of handles for the `IO::CatHandle` to read from and can deal with a mixed collection of [`Cool`](/type/Cool), [`IO::Path`](/type/IO/Path), and [`IO::Handle`](/type/IO/Handle) (including [`IO::Pipe`](/type/IO/Pipe)) objects. As input from `IO::CatHandle` is processed (so operations won't happen during `.new` call, but only when `@handles`' data is needed), it will walk through the `@handles` list, processing each argument as follows:
* the [`Cool`](/type/Cool) objects will be coerced to [`IO::Path`](/type/IO/Path);
* [`IO::Path`](/type/IO/Path) objects will be opened for reading using the `IO::CatHandle`'s (invocant's) attributes for [`open`](/routine/open) calls;
* un-opened [`IO::Handle`](/type/IO/Handle) objects will be opened in the same fashion as [`IO::Path`](/type/IO/Path) objects;
* and already opened [`IO::Handle`](/type/IO/Handle) objects will have all of their attributes set to the attributes of the invocant `IO::CatHandle`.
In short, all the `@handles` end up as [`IO::Handle`](/type/IO/Handle) objects opened in the same mode and with the same attributes as the invocant `IO::CatHandle`.
See [`.on-switch` method](/type/IO/CatHandle#method_on-switch) for details on the `:&on-switch` named argument, which by default is not set.
The [`:$encoding`](/type/IO/CatHandle#method_encoding) named argument specifies the handle's encoding and accepts the same values as [`IO::Handle.encoding`](/type/IO/Handle#method_encoding). Set `:$bin` named argument to `True` if you wish the handle to be in binary mode. Attempting to specify both a defined `:$encoding` and a `True` `:$bin` is a fatal error resulting in `X::IO::BinaryAndEncoding` exception thrown. If neither `:$encoding` is set nor `:$bin` set to a true value, the handle will default to `utf8` encoding.
The `:$chomp` and `:$nl-in` arguments have the same meaning as in [`IO::Handle`](/type/IO/Handle) and take and default to the same values.
# [In Supplier::Preserving](#___top "go to top of document")[§](#(Supplier::Preserving)_method_new "direct link")
See primary documentation
[in context](/type/Supplier/Preserving#method_new)
for **method new**.
```raku
method new()
```
The [`Supplier`](/type/Supplier) constructor.
# [In Nil](#___top "go to top of document")[§](#(Nil)_method_new "direct link")
See primary documentation
[in context](/type/Nil#method_new)
for **method new**.
```raku
method new(*@)
```
Returns `Nil`
# [In IO::Path](#___top "go to top of document")[§](#(IO::Path)_method_new "direct link")
See primary documentation
[in context](/type/IO/Path#method_new)
for **method new**.
```raku
multi method new(Str:D $path, IO::Spec :$SPEC = $*SPEC, Str() :$CWD = $*CWD)
multi method new(
:$basename!, :$dirname = '.', :$volume = ''
IO::Spec :$SPEC = $*SPEC, Str() :$CWD = $*CWD
)
```
Creates a new `IO::Path` object from a path string (which is being parsed for volume, directory name and basename), or from volume, directory name and basename passed as named arguments.
The path's operation will be performed using `:$SPEC` semantics (defaults to current [`$*SPEC`](/language/variables#Dynamic_variables)) and will use `:$CWD` as the directory the path is relative to (defaults to [`$*CWD`](/language/variables#Dynamic_variables)).
If `$path` includes the null byte, it will throw an Exception with a "Cannot use null character (U+0000) as part of the path" message.
# [In IO::Path::Unix](#___top "go to top of document")[§](#(IO::Path::Unix)_method_new "direct link")
See primary documentation
[in context](/type/IO/Path/Unix#method_new)
for **method new**.
Same as [`IO::Path.new`](/type/IO/Path#method_new), except `:$SPEC` cannot be set and defaults to [`IO::Spec::Unix`](/type/IO/Spec/Unix), regardless of the operating system the code is being run on.
# [In Junction](#___top "go to top of document")[§](#(Junction)_method_new "direct link")
See primary documentation
[in context](/type/Junction#method_new)
for **method new**.
```raku
multi method new(Junction: \values, Str :$type!)
multi method new(Junction: Str:D \type, \values)
```
These constructors build a new junction from the type that defines it and a set of values.
```raku
my $j = Junction.new(<Þor Oðinn Loki>, type => "all");
my $n = Junction.new( "one", 1..6 )
```
The main difference between the two multis is how the type of the `Junction` is passed as an argument; either positionally as the first argument, or as a named argument using `type`.
# [In IO::Path::Win32](#___top "go to top of document")[§](#(IO::Path::Win32)_method_new "direct link")
See primary documentation
[in context](/type/IO/Path/Win32#method_new)
for **method new**.
Same as [`IO::Path.new`](/type/IO/Path#method_new), except `:$SPEC` cannot be set and defaults to [`IO::Spec::Win32`](/type/IO/Spec/Win32), regardless of the operating system the code is being run on.
# [In Thread](#___top "go to top of document")[§](#(Thread)_method_new "direct link")
See primary documentation
[in context](/type/Thread#method_new)
for **method new**.
```raku
method new(:&code!, Bool :$app_lifetime = False, Str :$name = '<anon>' --> Thread:D)
```
Creates and returns a new `Thread`, without starting it yet. `&code` is the code that will be run in a separate thread.
`$name` is a user-specified string that identifies the thread.
If `$app_lifetime` is set to `True`, then the thread is killed when the main thread of the process terminates. If set to `False`, the process will only terminate when the thread has finished.
# [In Int](#___top "go to top of document")[§](#(Int)_method_new "direct link")
See primary documentation
[in context](/type/Int#method_new)
for **method new**.
```raku
multi method new(Any:U $type)
multi method new(Any:D \value --> Int:D)
multi method new(int \value --> Int:D)
```
The first form will throw an exception; the second and third form will create a new Int from the actual integer value contained in the variable.
# [In X::NYI](#___top "go to top of document")[§](#(X::NYI)_method_new "direct link")
See primary documentation
[in context](/type/X/NYI#method_new)
for **method new**.
```raku
method new( :$feature, :$did-you-mean, :$workaround)
```
This is the default constructor for `X:NYI` which can take three parameters with obvious meanings.
```raku
class Nothing {
method ventured( $sub, **@args) {
X::NYI.new( feature => &?ROUTINE.name,
did-you-mean => "gained",
workaround => "Implement it yourself" ).throw;
}
}
my $nothing = Nothing.new;
$nothing.ventured("Nothing", "Gained");
```
In this case, we are throwing an exception that indicates that the `ventured` routine has not been implemented; we use the generic `&?ROUTINE.name` to not tie the exception to the method name in case it is changed later on. This code effectively throws this exception
```raku
# OUTPUT:
# ventured not yet implemented. Sorry.
# Did you mean: gained?
# Workaround: Implement it yourself
# in method ventured at NYI.raku line 6
# in block <unit> at NYI.raku line 14
```
Using the exception properties, it composes the message that we see there.
# [In DateTime](#___top "go to top of document")[§](#(DateTime)_method_new "direct link")
See primary documentation
[in context](/type/DateTime#method_new)
for **method new**.
```raku
multi method new(Int :$year!, Int :$month = 1, Int :$day = 1,
Int :$hour = 0, Int :$minute = 0, :$second = 0,
Int :$timezone = 0, :&formatter)
multi method new(Date :$date!,
Int :$hour = 0, Int :$minute = 0, :$second = 0,
Int :$timezone = 0, :&formatter)
multi method new(Int() $year, Int() $month, Int() $day,
Int() $hour, Int $minute, $second,
Int() :$timezone = 0, :&formatter)
multi method new(Instant:D $i, :$timezone= |
## new.md
## Chunk 2 of 2
0, :&formatter)
multi method new(Numeric:D $posix, :$timezone=0, :&formatter)
multi method new(Str:D $format, :$timezone=0, :&formatter)
```
Creates a new `DateTime` object. One option for creating a new DateTime object is from the components (year, month, day, hour, ...) separately. Another is to pass a [`Date`](/type/Date) object for the date component, and specify the time component-wise. Yet another is to obtain the time from an [`Instant`](/type/Instant), and only supply the time zone and formatter. Or instead of an Instant you can supply a [`Numeric`](/type/Numeric) as a UNIX timestamp.
You can also supply a [`Str`](/type/Str) formatted in ISO 8601 timestamp notation or as a full [RFC 3339](https://tools.ietf.org/html/rfc3339) date and time. Strings should be formatted as `yyyy-mm-ddThh:mm:ssZ` or `yyyy-mm-ddThh:mm:ss+0100`. We are somewhat less restrictive than the ISO 8601 standard, as we allow Unicode digits and mixing of condensed and extended time formats.
An invalid input string throws an exception of type [`X::Temporal::InvalidFormat`](/type/X/Temporal/InvalidFormat). If you supply a string that includes a time zone and supply the `timezone` named argument, an exception of type [`X::DateTime::TimezoneClash`](/type/X/DateTime/TimezoneClash) is thrown.
```raku
my $datetime = DateTime.new(year => 2015,
month => 1,
day => 1,
hour => 1,
minute => 1,
second => 1,
timezone => 1);
$datetime = DateTime.new(date => Date.new('2015-12-24'),
hour => 1,
minute => 1,
second => 1,
timezone => 1);
$datetime = DateTime.new(2015, 1, 1, # First January of 2015
1, 1, 1); # Hour, minute, second with default time zone
$datetime = DateTime.new(now); # Instant.
# from a Unix timestamp
say $datetime = DateTime.new(1470853583.3); # OUTPUT: «2016-08-10T18:26:23.300000Z»
$datetime = DateTime.new("2015-01-01T03:17:30+0500") # Formatted string
```
Since Rakudo release 2022.03, the `day` parameter can be a [`Callable`](/type/Callable), with `*` returning the last day in the month, and `*-n` returning the last but `n`.
Since Rakudo release 2022.07, it is also possible to just specify a "YYYY-MM-DD" string to indicate midnight on the given date.
```raku
say DateTime.new("2023-03-04"); # OUTPUT: «2023-03-04T00:00:00Z»
```
# [In IO::Path::QNX](#___top "go to top of document")[§](#(IO::Path::QNX)_method_new "direct link")
See primary documentation
[in context](/type/IO/Path/QNX#method_new)
for **method new**.
Same as [`IO::Path.new`](/type/IO/Path#method_new), except `:$SPEC` cannot be set and defaults to [`IO::Spec::QNX`](/type/IO/Spec/QNX), regardless of the operating system the code is being run on.
# [In Formatter](#___top "go to top of document")[§](#(Formatter)_method_new "direct link")
See primary documentation
[in context](/type/Formatter#method_new)
for **method new**.
```raku
method new($format --> Callable:D)
```
Returns a cached [`Callable`](/type/Callable) object from a `sprintf` compatible format string. Will create a new [`Callable`](/type/Callable) object if the given format string had not been seen before.
```raku
use v6.e.PREVIEW;
my &zero5 = Formatter.new("%05d");
say zero5(42); # OUTPUT: «00042»
```
# [In ComplexStr](#___top "go to top of document")[§](#(ComplexStr)_method_new "direct link")
See primary documentation
[in context](/type/ComplexStr#method_new)
for **method new**.
```raku
method new(Complex $i, Str $s)
```
The constructor requires both the [`Complex`](/type/Complex) and the [`Str`](/type/Str) value, when constructing one directly the values can be whatever is required:
```raku
my $f = ComplexStr.new(42+0i, "forty two (but complicated)");
say +$f; # OUTPUT: «42+0i»
say ~$f; # OUTPUT: «"forty two (but complicated)"»
```
# [In Semaphore](#___top "go to top of document")[§](#(Semaphore)_method_new "direct link")
See primary documentation
[in context](/type/Semaphore#method_new)
for **method new**.
```raku
method new( int $permits )
```
Initialize the semaphore with the number of permitted accesses. E.g. when set to 2, program threads can pass the acquire method twice until it blocks on the third time acquire is called.
# [In Supplier](#___top "go to top of document")[§](#(Supplier)_method_new "direct link")
See primary documentation
[in context](/type/Supplier#method_new)
for **method new**.
```raku
method new()
```
The `Supplier` constructor.
# [In RatStr](#___top "go to top of document")[§](#(RatStr)_method_new "direct link")
See primary documentation
[in context](/type/RatStr#method_new)
for **method new**.
```raku
method new(Rat $i, Str $s)
```
The constructor requires both the [`Rat`](/type/Rat) and the [`Str`](/type/Str) value, when constructing one directly the values can be whatever is required:
```raku
my $f = RatStr.new(42.1, "forty two and a bit");
say +$f; # OUTPUT: «42.1»
say ~$f; # OUTPUT: «"forty two and a bit"»
```
# [In RakuAST::Doc::Declarator](#___top "go to top of document")[§](#(RakuAST::Doc::Declarator)_method_new "direct link")
See primary documentation
[in context](/type/RakuAST/Doc/Declarator#method_new)
for **method new**.
```raku
method new(
Str:D :$WHEREFORE, # the associated RakuAST object
:@leading, # leading lines of documentation
:@trailing # trailing lines of documentation
)
```
The `new` method can be called to create a new `RakuAST::Doc::Declarator` object. It only takes named arguments.
```raku
# there is no syntax for creating just a ::Declarator object
my $declarator = RakuAST::Doc::Declarator.new(
:WHEREFORE(RakuAST::VarDeclaration::Simple.new(...)),
:leading("line 1 leading","line 2 leading"),
:trailing("line 1 trailing","line 2 trailing")
);
```
Note that the leading and trailing documentation may contain any left margin whitespace.
# [In Backtrace](#___top "go to top of document")[§](#(Backtrace)_method_new "direct link")
See primary documentation
[in context](/type/Backtrace#method_new)
for **method new**.
```raku
multi method new()
multi method new(Int:D $offset)
multi method new(Mu \ex)
multi method new(Mu \ex, Int:D $offset)
multi method new(List:D $bt)
multi method new(List:D $bt, Int:D $offset)
```
Creates a new backtrace, using its calling location as the origin of the backtrace or the `$offset` that is passed as a parameter. If an object or a list (that will already contain a backtrace in list form) is passed, they will be used instead of the current code.
```raku
my $backtrace = Backtrace.new;
```
# [In Date](#___top "go to top of document")[§](#(Date)_method_new "direct link")
See primary documentation
[in context](/type/Date#method_new)
for **method new**.
```raku
multi method new($year, $month, $day, :&formatter --> Date:D)
multi method new(:$year!, :$month = 1, :$day = 1 --> Date:D)
multi method new(Str $date --> Date:D)
multi method new(Instant:D $dt --> Date:D)
multi method new(DateTime:D $dt --> Date:D)
```
Creates a new `Date` object, either from a triple of (year, month, day) that can be coerced to integers, or from a string of the form `YYYY-MM-DD` ([ISO 8601](https://en.wikipedia.org/wiki/ISO_8601)), or from an Instant or DateTime object. Optionally accepts a formatter as a named parameter.
```raku
my $date = Date.new(2042, 1, 1);
$date = Date.new(year => 2042, month => 1, day => 1);
$date = Date.new("2042-01-01");
$date = Date.new(Instant.from-posix: 1482155532);
$date = Date.new(DateTime.now);
```
Since Rakudo 2022.03, the "day" argument can also be a callable, with `*` representing the last day in a month, and the possibility of getting to the day counting from the last one:
```raku
say Date.new(2042, 2, *); # OUTPUT: «2042-02-28»
say Date.new(2044, 2, *); # OUTPUT: «2044-02-29»
```
# [In role Rational](#___top "go to top of document")[§](#(role_Rational)_method_new "direct link")
See primary documentation
[in context](/type/Rational#method_new)
for **method new**.
```raku
method new(NuT:D $numerator, DeT:D $denominator --> Rational:D)
```
Creates a new rational object from numerator and denominator, which it normalizes to the lowest terms. The `$denominator` can be zero, in which case the numerator is normalized to `-1`, `0`, or `1` depending on whether the original is negative, zero, or positive, respectively.
|
## dist_zef-dwarring-Native-Packing.md
# Native-Packing-raku
[](https://travis-ci.org/pdf-raku/Native-Packing-raku)
## Description
Native::Packing is a simple solution for structured reading
and writing of binary numerical data.
## Example
```
use v6;
use Native::Packing :Endian;
# open a GIF read the header
my class LogicalDescriptor
does Native::Packing[Endian::Vax] {
has uint16 $.width;
has uint16 $.height;
has uint8 $.flags;
has uint8 $.bgColorIndex;
has uint8 $.aspect;
}
my $fh = "t/lightbulb.gif".IO.open( :r, :bin);
my $offset = 6; # skip GIF header
my LogicalDescriptor $screen .= read: $fh, :$offset;
say "GIF has size {$screen.width} X {$screen.height}";
```
It currently handles records containing native integers (`int8`, `uint8`, `int16`, etc),
numerics (`num32`, `num64`) and sub-records of type `Native::Packing`.
* Data may read be and written to binary files, via the `read` and `write` methods
* Or read and written to buffers via the `unpack` and `pack` methods.
## Endianess
The two fixed modes are:
* Vax (little endian) - least significant byte written first
* Network (big endian) - most significant byte written first
The endianess of the binary format needs to be known to correctly
read and write to it.
There is also a platform-dependant `Host` mode. This will read and write
binary data in the same endianess as the host computer.
Endian Examples:
```
use Native::Packing :Endian;
class C { has int16 $.a }
my $c = C.new: :a(42);
say ($c but Native::Packing[Vax]).pack; # Buf[uint8]:0x<2a 00>
say ($c but Native::Packing[Network]).pack; # Buf[uint8]:0x<00 2a>
say ($c but Native::Packing[Host]).pack; # Depends on your host
```
|
## dist_github-colomon-Math-OddFunctions.md
This simple module tries to implement the functions described in
```
http://www.johndcook.com/blog/2010/06/07/math-library-functions-that-seem-unnecessary/
```
Ideally I think these should be in p6's core, but I thought having
a module for them would be a useful first step.
|
## dist_zef-dwarring-PDF-Font-Loader.md
[](https://github.com/pdf-raku/PDF-Font-Loader-raku/actions)
[[Raku PDF Project]](https://pdf-raku.github.io)
/ [[PDF-Font-Loader Module]](https://pdf-raku.github.io/PDF-Font-Loader-raku)
## Name
PDF::Font::Loader
## Synopsis
```
# load a font from a file
use PDF::Font::Loader :&load-font;
use PDF::Content::FontObj;
my PDF::Content::FontObj $deja;
$deja = PDF::Font::Loader.load-font: :file<t/fonts/DejaVuSans.ttf>;
-- or --
$deja = load-font: :file<t/fonts/DejaVuSans.ttf>;
# find/load the best matching system font
# *** requires FontConfig ***
use PDF::Font::Loader :load-font, :find-font;
my Str $file = find-font( :family<DejaVu>, :slant<italic> );
my PDF::Content::FontObj $deja-vu = load-font: :$file;
# use the font to add text to a PDF
use PDF::Lite;
my PDF::Lite $pdf .= new;
my $font-size = 12; # point-size
$pdf.add-page.text: {
.font = $deja, $font-size;
.text-position = [10, 600];
.say: 'Hello, world';
}
$pdf.save-as: "/tmp/example.pdf";
```
## Description
This module provides font loading and handling for [PDF::Lite](https://pdf-raku.github.io/PDF-Lite-raku), [PDF::API6](https://pdf-raku.github.io/PDF-API6) and other PDF modules.
## Classes in this distribution
* [PDF::Font::Loader](https://pdf-raku.github.io/PDF-Font-Loader-raku/PDF/Font/Loader) - external font loader
* [PDF::Font::Loader::Dict](https://pdf-raku.github.io/PDF-Font-Loader-raku/PDF/Font/Loader/Dict) - PDF font dictionary loader
* [PDF::Font::Loader::FontObj](https://pdf-raku.github.io/PDF-Font-Loader-raku/PDF/Font/Loader/FontObj) - Loaded basic font representation
* [PDF::Font::Loader::FontObj::CID](https://pdf-raku.github.io/PDF-Font-Loader-raku/PDF/Font/Loader/FontObj/CID) - Loaded CID font representation
* [PDF::Font::Loader::Enc](https://pdf-raku.github.io/PDF-Font-Loader-raku/PDF/Font/Loader/Enc) - Font encoder/decoder base class
* [PDF::Font::Loader::Enc::Type1](https://pdf-raku.github.io/PDF-Font-Loader-raku/PDF/Font/Loader/Enc/Type1) - Typical type-1 encodings (win mac std)
* [PDF::Font::Loader::Enc::Identity16](https://pdf-raku.github.io/PDF-Font-Loader-raku/PDF/Font/Loader/Enc/Identity16) - Identity-H/Identity-V 2 byte encoding
* [PDF::Font::Loader::Enc::CMAP](https://pdf-raku.github.io/PDF-Font-Loader-raku/PDF/Font/Loader/Enc/CMap) - General CMap driven variable encoding
* [PDF::Font::Loader::Enc::Unicode](https://pdf-raku.github.io/PDF-Font-Loader-raku/PDF/Font/Loader/Enc/Unicode) - UTF-8, UTF-16 and UTF-32 specific encoding
* [PDF::Font::Loader::Glyph](https://pdf-raku.github.io/PDF-Font-Loader-raku/PDF/Font/Loader/Glyph) - Glyph representation class
## Install
PDF::Font::Loader depends on:
[Font::FreeType](https://pdf-raku.github.io/Font-FreeType-raku/) Raku module which further depends on the [freetype](https://www.freetype.org/download.html) library, so you must install that prior to installing this module.
The `find-font` method requires installation of the [FontConfig](https://pdf-raku.github.io/FontConfig/) library.
[PDF::Font::Loader::HarfBuzz](https://pdf-raku.github.io/PDF-Font-Loader-HarfBuzz-raku) - is an optional module, but needs to be installed for font-shaping.
[HarfBuzz::Subset](https://harfbuzz-raku.github.io/HarfBuzz-Subset-raku/) - an optional module, but needs to be installed for font-subsetting.
|
## dist_cpan-ANTONOV-Lingua-StopwordsISO.md
# Raku-Lingua-StopwordsISO
## In brief
This is a Raku package for stop words of different languages.
Follows
["Stopwords ISO" project](https://github.com/stopwords-iso), [GDr1],
and Raku package
["Lingua::Stopwords"](https://raku.land/cpan:CHSANCH/Lingua::Stopwords), [CSp1].
This package has the JSON file
["stopwords-iso.json"](https://github.com/stopwords-iso/stopwords-iso/blob/master/stopwords-iso.json)
from [GDr1] as a resource file.
---
## Usage examples
### `stopwords-iso`
The function `stopwords-iso` takes as an argument a language spec (e.g. 'en' or 'English') and
returns a `SetHash`:
```
use Lingua::StopwordsISO;
"I Want You To Deal With Your Problems By Becoming Rich!"
.words
.map({ $_.lc => $_.lc ∈ stopwords-iso('English')})
```
```
# (i => True want => True you => True to => True deal => False with => True your => True problems => True by => True becoming => True rich! => False)
```
If several languages are specified then the result is a `Hash` of `SetHash` objects:
```
stopwords-iso(<Bulgarian Czech English Russian Spanish>)>>.elems
```
```
# {Bulgarian => 259, Czech => 423, English => 1298, Russian => 558, Spanish => 732}
```
With `stopwords-iso('all')` the stop words of all languages (known by the package) can be optained.
### `delete-stopwords`
The function `delete-stopwords` deletes the stop words in a string:
```
delete-stopwords('English',
'What fun is there in making plans,
acquiring discipline in organizing thoughts,
devoting attention to detail,
and learning to be self-critical?')
```
```
# fun plans,
# acquiring discipline organizing ,
# devoting attention ,
# learning self-critical?
```
The first, language spec argument can be a word ('English', 'Russian', 'Spanish', etc.)
or an abbreviation ('en', 'ru', 'es', etc.)
If only one argument is given to `delete-stopwords` then the language spec is 'English'.
---
## Command Line Interface (CLI)
The package provides the CLI functions `stopwords-iso` and `delete-stopwords`.
### `stopwords-iso`
Here is the usage message of `stopwords-iso`:
```
> stopwords-iso --help
Usage:
stopwords-iso [-f|--format=<Str>] [<langs> ...] -- Gives stop words for the specified languages in the specified format.
stopwords-iso [-f|--format=<Str>] -- Gives stop words for language specs in (pipeline) input.
[<langs> ...] Languages to get the stop words for.
-f|--format=<Str> Output format one of 'text', 'json', or 'raku'. [default: 'text']
```
Here are example shell commands:
```
> stopwords-iso bg
# а автентичен аз ако ала бе без беше би бивш бивша бившо бил била били било благодаря близо бъдат бъде бяха
# в вас ваш ваша вероятно вече взема ви вие винаги внимава време все всеки всички всичко всяка във въпреки върху
# г ги главен главна главно глас го година години годишен д да дали два двама двамата две двете ден днес дни до
# добра добре добро добър докато докога дори досега доста друг друга други е евтин едва един една еднаква еднакви
# еднакъв едно екип ето живот за забавям зад заедно заради засега заспал затова защо защото и из или им има имат
# иска й каза как каква какво както какъв като кога когато което които кой който колко която къде където към лесен
# лесно ли лош м май малко ме между мек мен месец ми много мнозина мога могат може мокър моля момента му н на над
# назад най направи напред например нас не него нещо нея ни ние никой нито нищо но нов нова нови новина някои някой
# няколко няма обаче около освен особено от отгоре отново още пак по повече повечето под поне поради после почти
# прави пред преди през при пък първата първи първо пъти равен равна с са сам само се сега си син скоро след следващ
# сме смях според сред срещу сте съм със също т т.н. тази така такива такъв там твой те тези ти то това тогава този
# той толкова точно три трябва тук тъй тя тях у утре харесва хиляди ч часа че често чрез ще щом юмрук я як
```
```
> stopwords-iso --format=json bg ru en | wc
# 2123 2158 31165
> stopwords-iso --format=json bg | wc
# 261 267 3707
> stopwords-iso --format=json en | wc
# 1300 1300 14171
> stopwords-iso --format=json ru | wc
# 560 586 9021
```
### `delete-stopwords`
Here is the usage message of `delete-stopwords`:
```
> delete-stopwords --help
Usage:
delete-stopwords [-l|--lang=<Str>] [-f|--format=<Str>] <text> -- Removes stop words in text.
delete-stopwords [-l|--lang=<Str>] [-f|--format=<Str>] [<words> ...] -- Removes stop words from a list of words.
delete-stopwords [-l|--lang=<Str>] [-f|--format=<Str>] -- Removes stop words in (pipeline) input.
<text> Text to remove stop words from.
-l|--lang=<Str> Language [default: 'English']
-f|--format=<Str> Output format one of 'text', 'lines', or 'raku'. [default: 'text']
[<words> ...] Text to remove stop words from.
```
Here are example shell commands:
```
> delete-stopwords -l=bg Покълването на посевите се очаква с търпение, пиене и сланина.
# Покълването посевите очаква търпение, пиене сланина.
```
```
> delete-stopwords "In theoretical computer science and formal language theory, regular expressions are used to describe so-called regular languages."
# theoretical science formal language theory, regular expressions so-called regular languages.
```
```
echo "In theoretical computer science and formal language theory, regular expressions are ..." | xargs -n1 | delete-stopwords
# theoretical science formal language theory, regular expressions ...
```
---
## Potential problems
In some cases `delete-stopwords` does not detect the word boundaries for texts
taken, say, from the World Wide Web.
This text "works":
```
my $text1 = qq:to/BGEND/;
Новите минимални размери на основните месечни работни заплати
на педагогическите специалисти са договорени с подписания на отраслово
ниво Анекс към Колективния трудов договор за системата на предучилищното
и училищното образование.
BGEND
say delete-stopwords('bg', $text1);
```
```
# Новите минимални размери основните месечни работни заплати
# педагогическите специалисти договорени подписания отраслово
# ниво Анекс Колективния трудов договор системата предучилищното
# училищното образование.
```
This does not:
```
my $text2 = qq:to/BGEND/;
Hoвитe минимaлни paзмepи нa ocнoвнитe мeceчни paбoтни зaплaти
нa пeдaгoгичecĸитe cпeциaлиcти ca дoгoвopeни c пoдпиcaния нa oтpacлoвo
нивo Aнeĸc ĸъм Koлeĸтивния тpyдoв дoгoвop зa cиcтeмaтa нa пpeдyчилищнoтo
и yчилищнoтo oбpaзoвaниe.
BGEND
say delete-stopwords('bg', $text2);
```
```
# Hoвитe минимaлни paзмepи нa ocнoвнитe мeceчни paбoтни зaплaти
# нa пeдaгoгичecĸитe cпeциaлиcти ca дoгoвopeни c пoдпиcaния нa oтpacлoвo
# нивo Aнeĸc ĸъм Koлeĸтивния тpyдoв дoгoвop зa cиcтeмaтa нa пpeдyчилищнoтo
# yчилищнoтo oбpaзoвaниe.
```
---
## References
[GDr1] Gene Diaz,
[Stopwords ISO project](https://github.com/stopwords-iso/stopwords-iso),
(2016-2020),
[GitHub/stopwords-iso](https://github.com/stopwords-iso).
[CSp1] Christian Sánchez,
[Lingua::Stopwords Raku package](https://raku.land/cpan:CHSANCH/Lingua::Stopwords),
(2018),
[Raku Land](https://raku.land).
|
## dist_zef-librasteve-Physics-Vector.md
[](https://opensource.org/licenses/Artistic-2.0)
# Physics::Vector
## Synopsis
```
#!/usr/bin/env raku
use Physics::Vector;
use Physics::Measure :ALL;
my $v1 = Physics::Vector.new([1, 2, 3], 'm/s');
my $v = (3,4,0), my $u = 'm/s';
my $v2 = Physics::Vector.new(:$v, :$u);
say ~$v2;
say ~($v1+$v2);
say ~(-$v1);
my $m = 10kg;
my $p = $m * $v1;
say ~$p;
```
### Copyright
copyright(c) 2024 Henley Cloud Consulting Ltd.
|
## uninames.md
uninames
Combined from primary sources listed below.
# [In Cool](#___top "go to top of document")[§](#(Cool)_routine_uninames "direct link")
See primary documentation
[in context](/type/Cool#routine_uninames)
for **routine uninames**.
```raku
sub uninames(Str:D)
method uninames()
```
Returns of a [`Seq`](/type/Seq) of Unicode names for the all the codepoints in the [`Str`](/type/Str) provided.
```raku
say ‘»ö«’.uninames.raku;
# OUTPUT: «("RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK", "LATIN SMALL LETTER O WITH DIAERESIS", "LEFT-POINTING DOUBLE ANGLE QUOTATION MARK").Seq»
```
Note this example, which gets a [`Seq`](/type/Seq) where each element is a [`Seq`](/type/Seq) of all the codepoints in that character.
```raku
say "Ḍ̇'oh".comb>>.uninames.raku;
# OUTPUT: «(("LATIN CAPITAL LETTER D WITH DOT BELOW", "COMBINING DOT ABOVE").Seq, ("APOSTROPHE",).Seq, ("LATIN SMALL LETTER O",).Seq, ("LATIN SMALL LETTER H",).Seq)»
```
See [uniname](/routine/uniname) for the name of the first codepoint of the first character in the provided [`Str`](/type/Str) and [uniparse](/routine/uniparse) for the opposite direction.
|
## reference.md
Raku language documentation
Broader explanations of fundamental topics and descriptions of Types and slangs
Fundamental topics
[Containers](language/containers)
A low-level explanation of Raku containers
[Contexts and contextualizers](language/contexts)
What are contexts and how to switch into them
[Control flow](language/control)
Statements used to control the flow of execution
[Data structures](language/structures)
How Raku deals with data structures and what we can expect from them
[Date and time functions](language/temporal)
Processing date and time in Raku
[Enumeration](language/enumeration)
An example using the enum type
[Exceptions](language/exceptions)
Using exceptions in Raku
[Functions](language/functions)
Functions and functional programming in Raku
[Grammars](language/grammars)
Parsing and interpreting text
[Hashes and maps](language/hashmap)
Working with associative arrays/dictionaries/hashes
[Independent routines](type/independent-routines)
Routines not defined within any class or role.
[Input/Output the definitive guide](language/io-guide)
Correctly use Raku IO
[Lists, sequences, and arrays](language/list)
Positional data constructs
[Metaobject protocol (MOP)](language/mop)
Introspection and the Raku object system
[Native calling interface](language/nativecall)
Call into dynamic libraries that follow the C calling convention
[Newline handling in Raku](language/newline)
How the different newline characters are handled, and how to change the behavior
[Numerics](language/numerics)
Numeric types available in Raku
[Object orientation](language/objects)
Object orientation in Raku
[Operators](language/operators)
Common Raku infixes, prefixes, postfixes, and more!
[Packages](language/packages)
Organizing and referencing namespaced program elements
[Performance](language/performance)
Measuring and improving runtime or compile-time performance
[Phasers](language/phasers)
Program execution phases and corresponding phaser blocks
[Pragmas](language/pragmas)
Special modules that define certain aspects of the behavior of the code
[Quoting constructs](language/quoting)
Writing strings and word lists, in Raku
[Raku native types](language/nativetypes)
Using the types the compiler and hardware make available to you
[Regexes](language/regexes)
Pattern matching against strings
[Sets, bags, and mixes](language/setbagmix)
Unordered collections of unique and weighted objects in Raku
[Signature literals](language/signatures)
A guide to signatures in Raku
[Statement prefixes](language/statement-prefixes)
Prefixes that alter the behavior of a statement or a set of them
[Subscripts](language/subscripts)
Accessing data structure elements by index or key
[Syntax](language/syntax)
General rules of Raku syntax
[System interaction](language/system)
Working with the underlying operating system and running applications
[Traits](language/traits)
Compile-time specification of behavior made easy
[Type system](language/typesystem)
Introduction to the type system of Raku
[Unicode](language/unicode)
Unicode support in Raku
[Unicode versus ASCII symbols](language/unicode_ascii)
Unicode symbols and their ASCII equivalents
[Variables](language/variables)
Variables in Raku
General reference
[Brackets](language/brackets)
Valid opening/closing paired delimiters
[Community](language/community)
Information about the people working on and using Raku
[FAQ](language/faq)
Frequently asked questions about Raku
[Glossary](language/glossary)
Glossary of Raku terminology
[Pod6 tables](language/tables)
Valid, invalid, and unexpected tables
[Rakudoc (aka Pod6)](language/pod)
A markup language for documenting Raku code. Pod6 is now known as RakuDoc V1, and a new [RakuDoc V2 specification](https://raku.github.io/rakudoc) exists.
[Terms](language/terms)
Raku terms
[Testing](language/testing)
Writing and running tests in Raku
[Traps to avoid](language/traps)
Traps to avoid when getting started with Raku
|
## mu.md
class Mu
The root of the Raku type hierarchy.
```raku
class Mu { }
```
The root of the Raku type hierarchy. For the origin of the name, see [Mu (negative)](https://en.wikipedia.org/wiki/Mu_%28negative%29) on Wikipedia. One can also say that there are many undefined values in Raku, and `Mu` is the *most undefined* value.
Note that most classes do not derive from `Mu` directly, but rather from [`Any`](/type/Any).
# [Methods](#class_Mu "go to top of document")[§](#Methods "direct link")
## [method iterator](#class_Mu "go to top of document")[§](#method_iterator "direct link")
```raku
method iterator(--> Iterator)
```
Coerces the invocant to a `list` by applying its [`.list`](/routine/list) method and uses [`iterator`](/type/Iterable#method_iterator) on it.
```raku
my $it = Mu.iterator;
say $it.pull-one; # OUTPUT: «(Mu)»
say $it.pull-one; # OUTPUT: «IterationEnd»
```
## [method defined](#class_Mu "go to top of document")[§](#method_defined "direct link")
```raku
multi method defined( --> Bool:D)
```
Returns `False` on a type object, and `True` otherwise.
```raku
say Int.defined; # OUTPUT: «False»
say 42.defined; # OUTPUT: «True»
```
A few types (like [`Failure`](/type/Failure)) override `defined` to return `False` even for instances:
```raku
sub fails() { fail 'oh noe' };
say fails().defined; # OUTPUT: «False»
```
## [routine defined](#class_Mu "go to top of document")[§](#routine_defined "direct link")
```raku
multi defined(Mu --> Bool:D)
```
invokes the `.defined` method on the object and returns its result.
## [routine isa](#class_Mu "go to top of document")[§](#routine_isa "direct link")
```raku
multi method isa(Mu $type --> Bool:D)
multi method isa(Str:D $type --> Bool:D)
```
Returns `True` if the invocant is an instance of class `$type`, a subset type or a derived class (through inheritance) of `$type`. [`does`](/routine/does#(Mu)_routine_does) is similar, but includes roles.
```raku
my $i = 17;
say $i.isa("Int"); # OUTPUT: «True»
say $i.isa(Any); # OUTPUT: «True»
role Truish {};
my $but-true = 0 but Truish;
say $but-true.^name; # OUTPUT: «Int+{Truish}»
say $but-true.does(Truish); # OUTPUT: «True»
say $but-true.isa(Truish); # OUTPUT: «False»
```
## [routine does](#class_Mu "go to top of document")[§](#routine_does "direct link")
```raku
method does(Mu $type --> Bool:D)
```
Returns `True` if and only if the invocant conforms to type `$type`.
```raku
my $d = Date.new('2016-06-03');
say $d.does(Dateish); # OUTPUT: «True» (Date does role Dateish)
say $d.does(Any); # OUTPUT: «True» (Date is a subclass of Any)
say $d.does(DateTime); # OUTPUT: «False» (Date is not a subclass of DateTime)
```
Unlike [`isa`](/routine/isa#(Mu)_routine_isa), which returns `True` only for superclasses, `does` includes both superclasses and roles.
```raku
say $d.isa(Dateish); # OUTPUT: «False»
```
Using the smartmatch operator [~~](/routine/~~) is a more idiomatic alternative.
```raku
my $d = Date.new('2016-06-03');
say $d ~~ Dateish; # OUTPUT: «True»
say $d ~~ Any; # OUTPUT: «True»
say $d ~~ DateTime; # OUTPUT: «False»
```
## [routine Bool](#class_Mu "go to top of document")[§](#routine_Bool "direct link")
```raku
multi Bool(Mu --> Bool:D)
multi method Bool( --> Bool:D)
```
Returns `False` on the type object, and `True` otherwise.
Many built-in types override this to be `False` for empty collections, the empty [string](/type/Str) or numerical zeros
```raku
say Mu.Bool; # OUTPUT: «False»
say Mu.new.Bool; # OUTPUT: «True»
say [1, 2, 3].Bool; # OUTPUT: «True»
say [].Bool; # OUTPUT: «False»
say %( hash => 'full' ).Bool; # OUTPUT: «True»
say {}.Bool; # OUTPUT: «False»
say "".Bool; # OUTPUT: «False»
say 0.Bool; # OUTPUT: «False»
say 1.Bool; # OUTPUT: «True»
say "0".Bool; # OUTPUT: «True»
```
## [method Capture](#class_Mu "go to top of document")[§](#method_Capture "direct link")
```raku
method Capture(Mu:D: --> Capture:D)
```
Returns a [`Capture`](/type/Capture) with named arguments corresponding to invocant's public attributes:
```raku
class Foo {
has $.foo = 42;
has $.bar = 70;
method bar { 'something else' }
}.new.Capture.say; # OUTPUT: «\(:bar("something else"), :foo(42))»
```
## [method Str](#class_Mu "go to top of document")[§](#method_Str "direct link")
```raku
multi method Str(--> Str)
```
Returns a string representation of the invocant, intended to be machine readable. Method [`Str`](/type/Str) warns on type objects, and produces the empty string.
```raku
say Mu.Str; # Use of uninitialized value of type Mu in string context.
my @foo = [2,3,1];
say @foo.Str # OUTPUT: «2 3 1»
```
## [routine gist](#class_Mu "go to top of document")[§](#routine_gist "direct link")
```raku
multi gist(+args --> Str)
multi method gist( --> Str)
```
Returns a string representation of the invocant, optimized for fast recognition by humans. As such lists will be truncated at 100 elements. Use `.raku` to get all elements.
The default `gist` method in `Mu` re-dispatches to the [raku](/routine/raku) method for defined invocants, and returns the type name in parenthesis for type object invocants. Many built-in classes override the case of instances to something more specific that may truncate output.
`gist` is the method that [say](/routine/say) calls implicitly, so `say $something` and `say $something.gist` generally produce the same output.
```raku
say Mu.gist; # OUTPUT: «(Mu)»
say Mu.new.gist; # OUTPUT: «Mu.new»
```
## [method perl](#class_Mu "go to top of document")[§](#method_perl "direct link")
```raku
multi method perl(Mu:)
```
Calls [`.raku`](/routine/raku) on the invocant. Since the change of the language name to Raku, this method is deprecated and might disappear in the near future. Use `.raku` instead.
## [method raku](#class_Mu "go to top of document")[§](#method_raku "direct link")
```raku
multi method raku(Mu:U:)
multi method raku(Mu:D:)
```
For type objects, returns its name if `.raku` has not been redefined from `Mu`, or calls `.raku` on the name of the type object otherwise.
```raku
say Str.raku; # OUTPUT: «Str»
```
For plain objects, it will conventionally return a representation of the object that can be used via [`EVAL`](/routine/EVAL) to reconstruct the value of the object.
```raku
say (1..3).Set.raku; # OUTPUT: «Set.new(1,2,3)»
```
## [method item](#class_Mu "go to top of document")[§](#method_item "direct link")
```raku
method item(Mu \item:) is raw
```
Forces the invocant to be evaluated in item context and returns the value of it.
```raku
say [1,2,3].item.raku; # OUTPUT: «$[1, 2, 3]»
say %( apple => 10 ).item.raku; # OUTPUT: «${:apple(10)}»
say "abc".item.raku; # OUTPUT: «"abc"»
```
## [method self](#class_Mu "go to top of document")[§](#method_self "direct link")
```raku
method self(--> Mu)
```
Returns the object it is called on.
## [method clone](#class_Mu "go to top of document")[§](#method_clone "direct link")
```raku
multi method clone(Mu:U: *%twiddles)
multi method clone(Mu:D: *%twiddles)
```
This method will clone type objects, or die if it's invoked with any argument.
```raku
say Num.clone( :yes )
# OUTPUT: «(exit code 1) Cannot set attribute values when cloning a type object in block <unit>»
```
If invoked with value objects, it creates a shallow clone of the invocant, including shallow cloning of private attributes. Alternative values for *public* attributes can be provided via named arguments with names matching the attributes' names.
```raku
class Point2D {
has ($.x, $.y);
multi method gist(Point2D:D:) {
"Point($.x, $.y)";
}
}
my $p = Point2D.new(x => 2, y => 3);
say $p; # OUTPUT: «Point(2, 3)»
say $p.clone(y => -5); # OUTPUT: «Point(2, -5)»
```
Note that `.clone` does not go the extra mile to shallow-copy `@.` and `%.` sigiled attributes and, if modified, the modifications will still be available in the original object:
```raku
class Foo {
has $.foo is rw = 42;
has &.boo is rw = { say "Hi" };
has @.bar = <a b>;
has %.baz = <a b c d>;
}
my $o1 = Foo.new;
with my $o2 = $o1.clone {
.foo = 70;
.bar = <Z Y>;
.baz = <Z Y X W>;
.boo = { say "Bye" };
}
# Hash and Array attribute modifications in clone appear in original as well:
say $o1;
# OUTPUT: «Foo.new(foo => 42, bar => ["Z", "Y"], baz => {:X("W"), :Z("Y")}, …»
say $o2;
# OUTPUT: «Foo.new(foo => 70, bar => ["Z", "Y"], baz => {:X("W"), :Z("Y")}, …»
$o1.boo.(); # OUTPUT: «Hi»
$o2.boo.(); # OUTPUT: «Bye»
```
To clone those, you could implement your own `.clone` that clones the appropriate attributes and passes the new values to `Mu.clone`, for example, via [`nextwith`](/language/functions#sub_nextwith).
```raku
class Bar {
has $.quux;
has @.foo = <a b>;
has %.bar = <a b c d>;
method clone { nextwith :foo(@!foo.clone), :bar(%!bar.clone), |%_ }
}
my $o1 = Bar.new( :42quux );
with my $o2 = $o1.clone {
.foo = <Z Y>;
.bar = <Z Y X W>;
}
# Hash and Array attribute modifications in clone do not affect original:
say $o1;
# OUTPUT: «Bar.new(quux => 42, foo => ["a", "b"], bar => {:a("b"), :c("d")})»
say $o2;
# OUTPUT: «Bar.new(quux => 42, foo => ["Z", "Y"], bar => {:X("W"), :Z("Y")})»
```
The `|%_` is needed to slurp the rest of the attributes that would have been copied via shallow copy.
## [method new](#class_Mu "go to top of document")[§](#method_new "direct link")
```raku
multi method new(*%attrinit)
```
Default method for constructing (create + initialize) new objects of a class. This method expects only named arguments which are then used to initialize attributes with accessors of the same name.
Classes may provide their own `new` method to override this default.
`new` triggers an object construction mechanism that calls submethods named `BUILD` in each class of an inheritance hierarchy, if they exist. See [the documentation on object construction](/language/objects#Object_construction) for more information.
## [method bless](#class_Mu "go to top of document")[§](#method_bless "direct link")
```raku
method bless(*%attrinit --> Mu:D)
```
Low-level object construction method, usually called from within `new`, implicitly from the default constructor, or explicitly if you create your own constructor. `bless` creates a new object of the same type as the invocant, using the named arguments to initialize attributes and returns the created object.
It is usually invoked within custom `new` method implementations:
```raku
class Point {
has $.x;
has $.y;
multi method new($x, $y) {
self.bless(:$x, :$y);
}
}
my $p = Point.new(-1, 1);
```
In this example we are declaring this `new` method to avoid the extra syntax of using pairs when creating the object. `self.bless` returns the object, which is in turn returned by `new`. `new` is declared as a `multi method` so that we can still use the default constructor like this: `Point.new( x => 3, y => 8 )`.
For more details see [the documentation on object construction](/language/objects#Object_construction).
## [method CREATE](#class_Mu "go to top of document")[§](#method_CREATE "direct link")
```raku
method CREATE(--> Mu:D)
```
Allocates a new object of the same type as the invocant, without initializing any attributes.
```raku
say Mu.CREATE.defined; # OUTPUT: «True»
```
## [method print](#class_Mu "go to top of document")[§](#method_print "direct link")
```raku
multi method print(--> Bool:D)
```
Prints value to `$*OUT` after stringification using `.Str` method without adding a newline at end.
```raku
"abc\n".print; # OUTPUT: «abc»
```
## [method put](#class_Mu "go to top of document")[§](#method_put "direct link")
```raku
multi method put(--> Bool:D)
```
Prints value to `$*OUT`, adding a newline at end, and if necessary, stringifying non-[`Str`](/type/Str) object using the `.Str` method.
```raku
"abc".put; # OUTPUT: «abc»
```
## [method say](#class_Mu "go to top of document")[§](#method_say "direct link")
```raku
multi method say()
```
Will [`say`](/type/IO/Handle#method_say) to [standard output](/language/variables#index-entry-$*OUT).
```raku
say 42; # OUTPUT: «42»
```
What `say` actually does is, thus, deferred to the actual subclass. In [most cases](/routine/say) it calls [`.gist`](/routine/gist) on the object, returning a compact string representation.
In non-sink context, `say` will always return `True`.
```raku
say (1,[1,2],"foo",Mu).map: so *.say ;
# OUTPUT: «1[1 2]foo(Mu)(True True True True)»
```
However, this behavior is just conventional and you shouldn't trust it for your code. It's useful, however, to explain certain behaviors.
`say` is first printing out in `*.say`, but the outermost `say` is printing the `True` values returned by the `so` operation.
## [method ACCEPTS](#class_Mu "go to top of document")[§](#method_ACCEPTS "direct link")
```raku
multi method ACCEPTS(Mu:U: $other)
```
`ACCEPTS` is the method that smartmatching with the [infix ~~](/routine/~~) operator and given/when invokes on the right-hand side (the matcher).
The `Mu:U` multi performs a type check. Returns `True` if `$other` conforms to the invocant (which is always a type object or failure).
```raku
say 42 ~~ Mu; # OUTPUT: «True»
say 42 ~~ Int; # OUTPUT: «True»
say 42 ~~ Str; # OUTPUT: «False»
```
Note that there is no multi for defined invocants; this is to allow autothreading of [junctions](/type/Junction), which happens as a fallback mechanism when no direct candidate is available to dispatch to.
## [method WHICH](#class_Mu "go to top of document")[§](#method_WHICH "direct link")
```raku
multi method WHICH(--> ObjAt:D)
```
Returns an object of type [`ObjAt`](/type/ObjAt) which uniquely identifies the object. Value types override this method which makes sure that two equivalent objects return the same return value from `WHICH`.
```raku
say 42.WHICH eq 42.WHICH; # OUTPUT: «True»
```
## [method WHERE](#class_Mu "go to top of document")[§](#method_WHERE "direct link")
```raku
method WHERE(Mu:)
```
Returns an [`Int`](/type/Int) representing the memory address of the object. Please note that in the Rakudo implementation of Raku, and possibly other implementations, the memory location of an object is **NOT** fixed for the lifetime of the object. So it has limited use for applications, and is intended as a debugging tool only.
## [method WHY](#class_Mu "go to top of document")[§](#method_WHY "direct link")
```raku
multi method WHY(Mu: --> Pod::Block::Declarator)
```
Returns the attached Pod::Block::Declarator.
For instance:
```raku
#| Initiate a specified spell normally
sub cast(Spell $s) {
do-raw-magic($s);
}
#= (do not use for class 7 spells)
say &cast.WHY;
# OUTPUT: «Initiate a specified spell normally(do not use for class 7 spells)»
```
See [Pod declarator blocks](/language/pod#Declarator_blocks) for details about attaching Pod to variables, classes, functions, methods, etc.
## [trait is export](#class_Mu "go to top of document")[§](#trait_is_export "direct link")
```raku
multi trait_mod:<is>(Mu:U \type, :$export!)
```
Marks a type as being exported, that is, available to external users.
```raku
my class SomeClass is export { }
```
A user of a module or class automatically gets all the symbols imported that are marked as `is export`.
See [Exporting and Selective Importing Modules](/language/modules#Exporting_and_selective_importing) for more details.
## [method return](#class_Mu "go to top of document")[§](#method_return "direct link")
```raku
method return()
```
The method `return` will stop execution of a subroutine or method, run all relevant [phasers](/language/phasers#Block_phasers) and provide invocant as a return value to the caller. If a return [type constraint](/language/signatures#Constraining_return_types) is provided it will be checked unless the return value is [`Nil`](/type/Nil). A control exception is raised and can be caught with [CONTROL](/language/phasers#CONTROL).
```raku
sub f { (1|2|3).return };
say f(); # OUTPUT: «any(1, 2, 3)»
```
## [method return-rw](#class_Mu "go to top of document")[§](#method_return-rw "direct link")
Same as method [`return`](/type/Mu#method_return) except that `return-rw` returns a writable container to the invocant (see more details here: [`return-rw`](/language/control#return-rw)).
## [method emit](#class_Mu "go to top of document")[§](#method_emit "direct link")
```raku
method emit()
```
Emits the invocant into the enclosing [supply](/language/concurrency#index-entry-supply_(on-demand)) or [react](/language/concurrency#react) block.
```raku
react { whenever supply { .emit for "foo", 42, .5 } {
say "received {.^name} ($_)";
}}
# OUTPUT:
# received Str (foo)
# received Int (42)
# received Rat (0.5)
```
## [method take](#class_Mu "go to top of document")[§](#method_take "direct link")
```raku
method take()
```
Returns the invocant in the enclosing [gather](/language/control#gather/take) block.
```raku
sub insert($sep, +@list) {
gather for @list {
FIRST .take, next;
take slip $sep, .item
}
}
say insert ':', <a b c>;
# OUTPUT: «(a : b : c)»
```
## [routine take](#class_Mu "go to top of document")[§](#routine_take "direct link")
```raku
sub take(\item)
```
Takes the given item and passes it to the enclosing `gather` block.
```raku
#| randomly select numbers for lotto
my $num-selected-numbers = 6;
my $max-lotto-numbers = 49;
gather for ^$num-selected-numbers {
take (1 .. $max-lotto-numbers).pick(1);
}.say; # six random values
```
## [routine take-rw](#class_Mu "go to top of document")[§](#routine_take-rw "direct link")
```raku
sub take-rw(\item)
```
Returns the given item to the enclosing `gather` block, without introducing a new container.
```raku
my @a = 1...3;
sub f(@list){ gather for @list { take-rw $_ } };
for f(@a) { $_++ };
say @a;
# OUTPUT: «[2 3 4]»
```
## [method so](#class_Mu "go to top of document")[§](#method_so "direct link")
```raku
method so()
```
Evaluates the item in Boolean context (and thus, for instance, collapses Junctions), and returns the result. It is the opposite of `not`, and equivalent to the [`?` operator](/language/operators#prefix_?).
One can use this method similarly to the English sentence: "If that is **so**, then do this thing". For instance,
```raku
my @args = <-a -e -b -v>;
my $verbose-selected = any(@args) eq '-v' | '-V';
if $verbose-selected.so {
say "Verbose option detected in arguments";
} # OUTPUT: «Verbose option detected in arguments»
```
The `$verbose-selected` variable in this case contains a [`Junction`](/type/Junction), whose value is `any(any(False, False), any(False, False), any(False, False), any(True, False))`. That is actually a *truish* value; thus, negating it will yield `False`. The negation of that result will be `True`. `so` is performing all those operations under the hood.
## [method not](#class_Mu "go to top of document")[§](#method_not "direct link")
```raku
method not()
```
Evaluates the item in Boolean context (leading to final evaluation of Junctions, for instance), and negates the result. It is the opposite of `so` and its behavior is equivalent to the [`!` operator](/language/operators#prefix_!).
```raku
my @args = <-a -e -b>;
my $verbose-selected = any(@args) eq '-v' | '-V';
if $verbose-selected.not {
say "Verbose option not present in arguments";
} # OUTPUT: «Verbose option not present in arguments»
```
Since there is also a [prefix version of `not`](/language/operators#prefix_not), this example reads better as:
```raku
my @args = <-a -e -b>;
my $verbose-selected = any(@args) eq '-v' | '-V';
if not $verbose-selected {
say "Verbose option not present in arguments";
} # OUTPUT: «Verbose option not present in arguments»
```
# [Typegraph](# "go to top of document")[§](#typegraphrelations "direct link")
Type relations for `Mu`
raku-type-graph
Mu
Mu
Any
Any
Any->Mu
Junction
Junction
Junction->Mu
[Expand chart above](/assets/typegraphs/Mu.svg)
|
## dist_zef-grondilu-Digest.md
[](https://ci.sparrowhub.io)
# Digests in raku
This is a pure [raku](https://raku.org/) repository implementing some digest
algorithms.
As of today (march 2023), raku still is fairly slow so if you need a faster way
to compute digest, consider using a
[nativecall](https://docs.raku.org/language/nativecall) binding to the OpenSSL
library instead.
## Synopsis
Nb. Since commit 911c292688ad056a98285f7930297c5e1aea3bfb,
there is no `Digest` module anymore, the submodules, `Digest::MD5`, `Digest::SHA1` and
so on must be used directly.
```
use Digest::MD5;
say md5 "hello";
use HMAC;
say hmac
key => "key",
msg => "The quick brown fox jumps over the lazy dog",
hash => &md5,
block-size => 64;
use Digest::SHA1;
say sha1 "Hola";
use Digest::SHA2;
say sha256 "Привет";
use Digest::RIPEMD;
say rmd160 "Saluton";
use Digest::SHA3;
say sha3_256 "Bonjour";
say shake256 "Merhaba", 16;
# This will keep printing blocks
.say for shake256 "नमस्ते", *;
```
## Features
Currently implemented:
* HMAC
* hmac
* Digest
* md5
* Digest::SHA1
* sha1
* Digest::SHA2
* sha224
* sha256
* sha384
* sha512
* Digest::SHA3
* sha3\_224
* sha3\_256
* sha3\_384
* sha3\_512
* shake128
* shake256
* Digest::RIPEMD :
* rmd160
## License
This work is published under the terms of the artistic license, as rakudo is.
See LICENSE file.
|
## enumhow.md
class Metamodel::EnumHOW
Metaobject representing a Raku enum.
```raku
class Metamodel::EnumHOW
does Metamodel::Naming
does Metamodel::Documenting
does Metamodel::Stashing
does Metamodel::AttributeContainer
does Metamodel::MethodContainer
does Metamodel::MultiMethodContainer
does Metamodel::RoleContainer
does Metamodel::BaseType
does Metamodel::MROBasedMethodDispatch
does Metamodel::MROBasedTypeChecking
does Metamodel::BUILDPLAN
does Metamodel::BoolificationProtocol
does Metamodel::REPRComposeProtocol
does Metamodel::Mixins
{ }
```
*Warning*: this class is part of the Rakudo implementation, and is not a part of the language specification.
`Metamodel::EnumHOW` is the metaclass behind the `enum` keyword.
```raku
enum Numbers <1 2>;
say Numbers.HOW ~~ Metamodel::EnumHOW; # OUTPUT: «True»
```
The following enum declaration:
```raku
our Int enum Error <Warning Failure Exception Sorrow Panic>;
```
Is roughly equivalent to this code using `Metamodel::EnumHOW`'s methods:
```raku
BEGIN {
my constant Error = Metamodel::EnumHOW.new_type: :name<Error>, :base_type(Int);
Error.^add_role: Enumeration;
Error.^add_role: NumericEnumeration;
Error.^compose;
for <Warning Failure Exception Sorrow Panic>.kv -> Int $v, Str $k {
# Note: Enumeration.pred and .succ will not work when adding enum
# values as pairs. They should be instances of the enum itself, but
# this isn't possible to do without nqp.
Error.^add_enum_value: $k => $v;
OUR::{$k} := Error.^enum_from_value: $v;
}
Error.^compose_values;
OUR::<Error> := Error;
}
```
# [Methods](#class_Metamodel::EnumHOW "go to top of document")[§](#Methods "direct link")
## [method new\_type](#class_Metamodel::EnumHOW "go to top of document")[§](#method_new_type "direct link")
```raku
method new_type(:$name!, :$base_type?, :$repr = 'P6opaque', :$is_mixin)
```
Creates a new type object for an enum. `$name` is the enum name, `$base_type` is the type given when the enum is declared using a scoped declaration (if any), and `$repr` is the type representation passed to the enum using the `repr` trait. `$is_mixin` is unused.
## [method add\_parent](#class_Metamodel::EnumHOW "go to top of document")[§](#method_add_parent "direct link")
```raku
method add_parent($obj, $parent)
```
Sets the base type of an enum. This can only be used if no base type was passed to `.new_type`.
## [method set\_export\_callback](#class_Metamodel::EnumHOW "go to top of document")[§](#method_set_export_callback "direct link")
```raku
method set_export_callback($obj, $callback)
```
Sets the enum's export callback, which is invoked when calling `.compose_values`. This is called when applying the `export` trait to an enum. `$callback` should be a routine of some sort, taking no arguments, that handles exporting the enum's values.
## [method export\_callback](#class_Metamodel::EnumHOW "go to top of document")[§](#method_export_callback "direct link")
```raku
method export_callback($obj)
```
Returns the export callback set by `.set_export_callback`.
## [method compose](#class_Metamodel::EnumHOW "go to top of document")[§](#method_compose "direct link")
```raku
method compose($obj, :$compiler_services)
```
Completes a type object for an enum. This is when any roles done by the enum are mixed in. This needs to be called before any enum values can be added using `.add_enum_value`.
## [method is\_composed](#class_Metamodel::EnumHOW "go to top of document")[§](#method_is_composed "direct link")
```raku
method is_composed($obj)
```
Returns 1 if the enum is composed, otherwise returns 0.
## [method compose\_values](#class_Metamodel::EnumHOW "go to top of document")[§](#method_compose_values "direct link")
```raku
method compose_values($obj)
```
Calls the export callback set by `.set_export_callback` and removes it from state. This should be called after adding the enum's values using `.add_enum_value`.
## [method set\_composalizer](#class_Metamodel::EnumHOW "go to top of document")[§](#method_set_composalizer "direct link")
```raku
method set_composalizer($c)
```
Sets the composalizer for an enum, which produces a type that can be mixed in with another. `$c` should be a routine of some that has the following signature:
```raku
:($type, $name, @enum_values)
```
## [method composalizer](#class_Metamodel::EnumHOW "go to top of document")[§](#method_composalizer "direct link")
```raku
method composalizer($obj)
```
Returns the composalizer set by `.set_composalizer`.
## [method add\_enum\_value](#class_Metamodel::EnumHOW "go to top of document")[§](#method_add_enum_value "direct link")
```raku
method add_enum_value($obj, $value)
```
Adds a value to this enum. `$value` should be an instance of the enum itself, as type [`Enumeration`](/type/Enumeration).
## [method enum\_values](#class_Metamodel::EnumHOW "go to top of document")[§](#method_enum_values "direct link")
```raku
method enum_values($obj)
```
Returns the values for the enum.
```raku
enum Numbers <10 20>;
say Numbers.^enum_values; # OUTPUT: {10 => 0, 20 => 1}
```
## [method elems](#class_Metamodel::EnumHOW "go to top of document")[§](#method_elems "direct link")
```raku
method elems($obj)
```
Returns the number of values.
```raku
enum Numbers <10 20>;
say Numbers.^elems; # OUTPUT: 2
```
## [method enum\_from\_value](#class_Metamodel::EnumHOW "go to top of document")[§](#method_enum_from_value "direct link")
```raku
method enum_from_value($obj, $value)
```
Given a value of the enum's base type, return the corresponding enum.
```raku
enum Numbers <10 20>;
say Numbers.^enum_from_value(0); # OUTPUT: 10
```
## [method enum\_value\_list](#class_Metamodel::EnumHOW "go to top of document")[§](#method_enum_value_list "direct link")
```raku
method enum_value_list($obj)
```
Returns a list of the enum values.
```raku
enum Numbers <10 20>;
say Numbers.^enum_value_list; # OUTPUT: (10 20)
```
|
## dist_github-nxadm-StrictNamedArguments.md
# StrictNamedArguments
[](https://travis-ci.org/nxadm/StrictNamedArguments)
While Perl 6 is strict on types when one is specified in the parameter
definition, the default behaviour for values for unknown named parameters
in methods (and constructors) is just to ignore them.
With this module, you can let Perl 6 throw an exception when invalid
named parameters are supplied. Let Perl6 watch yours fingers for these typos.
See <https://perl6advent.wordpress.com/2015/12/13/a-new-trait-for-old-methods/>
Usage:
```
use v6;
use StrictNamedArguments;
# Just use the trait 'strict' for methods
class Foo { # your class
has $.valid; # attribute, used by .new
# A regular method that expects a named argument:
# msg => 'some_value'
# and returns the value in upper case (in this example)
method shout(:$msg) is strict { $msg.uc }
# The Perl6 constructor is a regular method and can also
# me made strict if you provide the method strictly.
# The syntax of named parameters is a hash to be blessed.
method new(:$valid) is strict { self.bless(valid => $valid) }
}
```
Example output for $foo.shout( msg\_ => 'some\_value' ) method call:
```
The method shout of Foo received an invalid named parameter(s): msg_
in method <anon> at /home/claudio/Code/StrictNamedArguments/lib/StrictNamedArguments.pm line 47
in any enter at gen/moar/m-Metamodel.nqp line 3927
in block <unit> at t/strict2.t line 19
```
|
## preserving.md
class Supplier::Preserving
Cached live Supply factory
```raku
class Supplier::Preserving is Supplier { }
```
This is a factory for live [`Supply`](/type/Supply)-type objects, and it provides the mechanism for emitting new values onto the supplies, whereby values are kept when no consumer has tapped into the [`Supply`](/type/Supply). Any tapping will consume the already stored and future values.
Starting a preserving [`Supply`](/type/Supply) and consuming its values after it is `done`:
```raku
my $p = Supplier::Preserving.new;
start for ^3 {
$p.emit($_);
LAST {
say „done after { now - BEGIN now}s“;
$p.done;
}
}
sleep 2;
react {
whenever $p.Supply { $_.say; }
whenever Promise.in(2) { done }
}
say „also done after { now - BEGIN now }s“
```
Will output:
｢output｣ without highlighting
```
```
done after 0.0638467s
0
1
2
also done after 4.0534119s
```
```
# [Methods](#class_Supplier::Preserving "go to top of document")[§](#Methods "direct link")
## [method new](#class_Supplier::Preserving "go to top of document")[§](#method_new "direct link")
```raku
method new()
```
The [`Supplier`](/type/Supplier) constructor.
|
## dist_github-ugexe-Grammar-HTTP.md
## Grammar::HTTP
Grammars for parsing HTTP headers, message bodies, and URIs
## Synopsis
```
use Grammar::HTTP;
my $request = "GET / HTTP/1.1\r\nHost: www.raku.org\r\n\r\n";
my $match = Grammar::HTTP.parse($request);
say $match;
# ｢GET / HTTP/1.1
# Host: www.raku.org
#
#｣
# HTTP-message => ｢GET / HTTP/1.1
# Host: www.raku.org
#
#｣
# start-line => ｢GET / HTTP/1.1
#｣
# request-line => ｢GET / HTTP/1.1
#｣
# method => ｢GET｣
# request-target => ｢/｣
# HTTP-version => ｢HTTP/1.1｣
# HTTP-name => ｢HTTP｣
# major => ｢1｣
# minor => ｢1｣
# header-field => ｢Host: www.raku.org｣
# name => ｢Host｣
# value => ｢www.raku.org｣
# host => ｢www.raku.org｣
# message-body => ｢｣
```
### Rules
```
token HTTP-start
token HTTP-headers
token HTTP-header
token HTTP-body
token HTTP-message
```
Parsing individual parts of the HTTP message can also be done by using a different rule. The default
`Grammar::HTTP.parse($str)` is really the same as `Grammar::HTTP.parse($str, :rule('HTTP-message')`.
So to parse just the start line you could do:
```
my $string = "GET /http.html HTTP/1.1\r\n";
say Grammar::HTTP.parse($string, :rule<HTTP-start>)'
# ｢GET /http.html HTTP/1.1
# ｣
# start-line => ｢GET /http.html HTTP/1.1
# ｣
# request-line => ｢GET /http.html HTTP/1.1
# ｣
# method => ｢GET｣
# request-target => ｢/http.html｣
# HTTP-version => ｢HTTP/1.1｣
# HTTP-name => ｢HTTP｣
# major => ｢1｣
# minor => ｢1｣
```
### Actions
`Grammar::HTTP::Actions` can be used to generate a structured hash from a HTTP response message
```
use Grammar::HTTP::Actions;
use Grammar::HTTP;
my $response = "HTTP/1.1 200 OK\r\n"
~ "Allow: GET, HEAD, PUT\r\n"
~ "Content-Type: text/html; charset=utf-8\r\n"
~ "Transfer-Encoding: chunked, gzip\r\n\r\n";
my $parsed = Grammar::HTTP.parse($response, :actions(Grammar::HTTP::Actions.new));
my %header = $parsed.<HTTP-message>.<header-field>>>.made;
dd %header;
# Hash %header = {
# :Allow($("GET", "HEAD", "PUT")),
# :Content-Type($[
# :type("text"),
# :subtype("html"),
# :parameters([ :charset("utf-8") ])
# ]),
# :Transfer-Encoding($("chunked", "gzip"))}
```
#### RFCs
[RFC1035](https://www.rfc-editor.org/rfc/rfc1035) Domain Names - Implementation and Specification
[RFC3066](https://www.rfc-editor.org/rfc/rfc3066) Tags for the Identification of Languages
[RFC4234](https://www.rfc-editor.org/rfc/rfc4234) Augmented BNF for Syntax Specifications: ABNF
[RFC5234](https://www.rfc-editor.org/rfc/rfc5234) Augmented BNF for Syntax Specifications: ABNF (replaces 4234)
[RFC7405](https://www.rfc-editor.org/rfc/rfc7405) Case-Sensitive String Support in ABNF
[RFC4647](https://www.rfc-editor.org/rfc/rfc4647) Matching of Language Tags
[RFC5322](https://www.rfc-editor.org/rfc/rfc5322) Internet Message Format
[RFC5646](https://www.rfc-editor.org/rfc/rfc5646) Tags for Identifying Languages
[RFC7230](https://www.rfc-editor.org/rfc/rfc7230) Hypertext Transfer Protocol (HTTP/1.1): Message Syntax and Routing
[RFC7231](https://www.rfc-editor.org/rfc/rfc7231) Hypertext Transfer Protocol (HTTP/1.1): Semantics and Content
[RFC7232](https://www.rfc-editor.org/rfc/rfc7232) Hypertext Transfer Protocol (HTTP/1.1): Conditional Requests
[RFC7233](https://www.rfc-editor.org/rfc/rfc7233) Hypertext Transfer Protocol (HTTP/1.1): Range Requests
[RFC7234](https://www.rfc-editor.org/rfc/rfc7234) Hypertext Transfer Protocol (HTTP/1.1): Caching
[RFC7235](https://www.rfc-editor.org/rfc/rfc7235) Hypertext Transfer Protocol (HTTP/1.1): Authentication
|
## dist_zef-raku-community-modules-Terminal-Width.md
# NAME
Terminal::Width - Get the current width of the terminal
# SYNOPSIS
```
use Terminal::Width;
# Default to 80 characters if we fail to get actual width:
my $width = terminal-width;
# Default to 100 characters if we fail to get actual width:
$width = terminal-width :default<100>;
# return a Failure if we fail to get actual width:
$width = terminal-width :default<0>;
```
# DESCRIPTION
This module tries to figure out the current width of the terminal the
program is running in. The module is known to work on Windows 10 command
prompt and Debian flavours of Linux. Untested on other systems, but should also
work on OSX.
# EXPORTED SUBROUTINES
## `terminal-width`
```
terminal-width (Int :$default = 80 --> Int|Failure)
```
Returns and `Int` representing the character width of the terminal.
Takes one optional named argument `:default` that specifies the width
to use if we fail to determine the actual width (defaults to `80`). If
`:default` is set to `0` the subroutine will return a `Failure` if it
can't determine the width.
# ⚠ SECURITY NOTE
On Windows, this module attempts to run program `mode` and on all other
systems it attempts to run `tput`. A clever attacker can manipulate what
the actual executed program is, resulting in it being executed
with the privileges of your script's user.
# REPOSITORY
Fork this module on GitHub:
<https://github.com/raku-community-modules/Terminal-Width>
# BUGS
To report bugs or request features, please use
<https://github.com/raku-community-modules/Terminal-Width/issues>
# AUTHOR
Zoffix Znet (<http://zoffix.com/>)
# LICENSE
You can use and distribute this module under the terms of the
The Artistic License 2.0. See the `LICENSE` file included in this
distribution for complete details.
|
## dist_zef-tony-o-envy.md
# envy
A nice utility for managing your dist environments. With this utility you can enable and disable certain module repositories without affecting the system wide repositories. Each repo is self contained and can easily be reset/updated without affecting the system's modules.
## installation
```
$ zef install Envy
```
## usage
If you want to fill up your terminal with message, all of these commands will also take `--debug`, `--info`, `--silent`, `--loglevel=<Int>` flags. `--silent` is only effective in commands where output is not required, `config` and `version` below both ignore this flag.
### zef install ...
To install modules to your named repo, you should use:
```
$ zef install --to='Envy#<name>' [<modules> ...]
```
The `to=` flag will let `zef` know which repository you'd like the module installed with.
### [-e|--enable = False] init [<names> ...]
Allows you to initialize multiple repos for general use and the `-e` flag provides a shortcut for enabling all of the provided repos.
### ls
Displays the repos that are managed by `envy`. A `+<name>` indicates the repo is enabled and a `-` prefix indicates a disabled repo. Typical output:
```
~ envy ls
==> + a1
==> + a2
==> + a3
==> + b1
==> - dev
==> - my-project
==> - test
```
### enable [<names> ...]
Enables the given repos system wide.
### disable [<names> ...]
Disables the given repos system wide.
### destroy [<names> ...]
Disables and then removes that repository from the file system.
### config
Displays the given config without any other marks so it can be piped to a formatter if desired.
### version
Displays the currently running version of envy.
### help [<command>]
Command is optional, displays help for the given command or for envy in general.
## troubleshooting
By default no named repos are initialized or used. When you use Envy this way, it uses the `$*TMPDIR` as a repository. This is effectively a no-op unless you go through the hassle of initializing and installing modules to that directory.
|
## dist_cpan-BRAKMIC-Verge-RPC-Client.md
# Perl6 Verge Client
This is a client for accessing the Verge [REST API](https://vergecurrency.com/langs/en/#developers)
More info about available API calls can be found [here](https://chainquery.com/bitcoin-api).
## Installation
`zef install .`
## LICENSE
[Artistic License 2.0](https://github.com/brakmic/Perl6-Verge-Client/blob/master/LICENSE)
|
## dist_zef-raku-community-modules-URL-Find.md
[](https://github.com/raku-community-modules/URL-Find/actions) [](https://github.com/raku-community-modules/URL-Find/actions) [](https://github.com/raku-community-modules/URL-Find/actions)
# NAME
URL::Find - find all the URLs in a set of text
# DESCRIPTION
By default it will match domain names that use unicode characters such as http://правительство.рф. To only match ASCII domains use the :ascii option. It will also find URL's that end in one of the restricted characters, so `https://www.google.com,` will pull out `https://www.google.com`. It will find all the URL's in a text by default, or you can specify a maximum number with the :limit option. By default it will only find http, https, ftp, git and ssh schemes, but you can specify `:any<1>` to match any schemes with legal characters.
### sub find-urls
```
sub find-urls(
Str $string,
Num :$limit is copy,
:$ascii,
:$any
) returns List
```
Accepts a string and returns a list of URL's. Optionally you can specify a limit to the number of URL's returned, or whether you want to only match URL's with ASCII domain names: :ascii<1> Matches only http https ftp git and ssh schemes by default. To match any scheme, use :any<1>
# AUTHOR
Samantha McVey
Source can be located at: <https://github.com/raku-community-modules/URL-Find> . Comments and Pull Requests are welcome.
# COPYRIGHT AND LICENSE
Copyright 2016 - 2018 Samantha McVey
Copyright 2024 The Raku Community
This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.
|
## dist_cpan-VRURG-Test-Async.md
# NAME
Test::Async - asynchronous, thread-sage testing
# SYNOPSYS
```
use Test::Async;
plan 2, :parallel;
subtest "Async 1" => {
plan 1;
pass "a test";
}
subtest "Async 2" => {
plan 1;
pass "another test";
}
```
# DESCRIPTION
`Test::Async` provides a framework and a base set of tests tools compatible with the standard Raku `Test` module. But contrary to the standard, `Test::Async` has been developed with two primary goals in mind: concurrency and extensibility.
Here is the key features provided:
* event-driven, threaded, and OO core
* easy development of 3rd party test bundles
* asynchronous and/or random execution of subtests
* support of threaded user code
The SYNOPSYS section provides an example where two subtests would be started in parallel, each in its own thread. This allows to achieve two goals: speed up big test suits by splitting them in smaller chunks; and testing for possible concurrency problems in tested code.
With
```
plan $count, :random;
```
subtests will be executed in random order. In this mode it is possible to catch another class of errors caused by code being dependent on the order execution.
It is also possible to combine both *parallel* and *random* modes of operation.
# READ MORE
[`Test::Async::Manual`](https://github.com/vrurg/raku-Test-Async/blob/v0.0.16/docs/md/Test/Async/Manual.md), [`Test::Async::CookBook`](https://github.com/vrurg/raku-Test-Async/blob/v0.0.16/docs/md/Test/Async/CookBook.md), [`Test::Async`](https://github.com/vrurg/raku-Test-Async/blob/v0.0.16/docs/md/Test/Async.md), [`Test::Async::Base`](https://github.com/vrurg/raku-Test-Async/blob/v0.0.16/docs/md/Test/Async/Base.md)
|
## dist_zef-raku-community-modules-JSON-Unmarshal.md
[](https://github.com/raku-community-modules/JSON-Unmarshal/actions) [](https://github.com/raku-community-modules/JSON-Unmarshal/actions) [](https://github.com/raku-community-modules/JSON-Unmarshal/actions)
# NAME
JSON::Unmarshal - turn JSON into an Object (the opposite of JSON::Marshal)
# SYNOPSIS
```
use JSON::Unmarshal;
class SomeClass {
has Str $.string;
has Int $.int;
}
my $json = '{ "string" : "string", "int" : 42 }';
my SomeClass $object = unmarshal($json, SomeClass);
say $object.string; # -> "string"
say $object.int; # -> 42
```
# DESCRIPTION
This provides a single exported subroutine to create an object from a JSON representation of an object.
It only initialises the "public" attributes (that is those with accessors created by declaring them with the '.' twigil. Attributes without acccessors are ignored.
## `unmarshal` Routine
`unmarshal` has the following signatures:
* `unmarshal(Str:D $json, Positional $obj, *%)`
* `unmarshal(Str:D $json, Associative $obj, *%)`
* `unmarshal(Str:D $json, Mu $obj, *%)`
* `unmarshal(%json, $obj, *%)`
* `unmarshal(@json, $obj, *%)`
The signatures with associative and positional JSON objects are to be used for pre-parsed JSON data obtained from a different source. For example, this may happen when a framework deserializes it for you.
The following named arguments are supported:
* **`Bool :$opt-in`**
When falsy then all attributes of a class are deserialized. When *True* then only those marked with `is json` trait provided by `JSON::OptIn` module are taken into account.
* **`Bool :$warn`**
If set to *True* then the module will warn about some non-critical problems like unsupported named arguments or keys in JSON structure for which there no match attributes were found.
* **`Bool :$die`** or **`Bool :$throw`**
This is two aliases of the same attribute with meaning, similar to `:warn`, but where otherwise a waning would be issued the module will throw an exception.
## Manual Unmarshalling
It is also possible to use `is unmarshalled-by` trait to control how the value is unmarshalled:
```
use JSON::Unmarshal
class SomeClass {
has Version $.version is unmarshalled-by(-> $v { Version.new($v) });
}
my $json = '{ "version" : "0.0.1" }';
my SomeClass $object = unmarshal($json, SomeClass);
say $object.version; # -> "v0.0.1"
```
The trait has two variants, one which takes a `Routine` as above, the other a `Str` representing the name of a method that will be called on the type object of the attribute type (such as "new"), both are expected to take the value from the JSON as a single argument.
# COPYRIGHT AND LICENSE
Copyright 2015 - 2017 Tadeusz Sośnierz
Copyright 2022 - 2025 Raku Community
This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.
|
## dist_cpan-HANENKAMP-HTTP-Headers.md
# TITLE
HTTP::Headers
# SUBTITLE
Tools for working with HTTP message headers
# SYNOPSIS
```
use HTTP::Headers :standard-names;
my $headers = HTTP::Headers.new;
$headers.Content-Type = 'text/html';
$headers.Content-Type.charset = "UTF-8";
$headers.Content-Length = $content.encode.bytes;
my $CRLF = "\x0d\x0a";
print "200 OK$CRLF;
print $headers.as-string(:eol($CRLF));
print $CRLF;
print $content;
```
# DESCRIPTION
This module provides convenient tools for working with HTTP headers. An emphasis has been placed on making it easy to use in a way that helps catch errors early. It has also been built for extensibility.
# Methods
## method new
```
method new(HTTP::Headers:U: @headers, Bool:D :$quiet = False --> HTTP::Headers:D)
method new(HTTP::Headers:U: %headers, Bool:D :$quiet = False --> HTTP::Headers:D)
method new(HTTP::Headers:U: Bool:D :$quiet = False, *@headers, *%headers --> HTTP::Headers:D)
```
Constructs a new object for working with headers. The `:$quiet` option can be used to suppress all warnings normally generated by this object.
The various `%headers` and `@headers` methods can be used to initialize the object from a list of pairs:
```
my $headers = HTTP::Headers.new:
::(Content-Type) => 'text/html',
::(Content-Length) => 42,
'X-Requested-With' => 'XMLHTTPRequest',
;
```
## method headers
```
multi method headers(HTTP::Headers:D: Pair:D @headers)
multi method headers(HTTP::Headers:D: %headers)
multi method headers(HTTP::Headers:D: *@headers, *%headers)
```
Sets all the headers given as pairs or named parameters.
## method header
```
multi method header(HTTP::Headers:D: HTTP::Header::Standard::Name $name --> HTTP::Header) is rw
multi method header(HTTP::Headers:D: Str $name --> HTTP::Header) is rw
```
This method is writable and allows the use of either the values in the `HTTP::Header::Standard::Name` enumeration or string values. In general, you should not use strings when you can use the enumeration in your code. By using the enumeration, you can discover typos at compile time.
```
use HTTP::Headers :standard-names;
$headers.header(Content-MIME-Type); # I forgot it's just Content-Type
# Undeclared name:
# Content-MIME-Type used at line 1
```
The library will remind you of this best practice if you use a string when you could use an enumeration:
```
$headers.header("Content-Type");
# Calling .header(Content-Type) is preferred to .header("Content-Type") for standard HTTP headers.
```
If you don't want to see these, you can ask the object or the method to be quiet:
```
$headers.header("Content-Type", :quiet);
# OR during construction
my $headers = HTTP::Headers.new(:$quiet);
```
When setting values on a header, you may set either a single or multiples.
```
$headers.header(Content-Length) = 42;
$headers.header(Accept) = "text/html", "text/*", "*/*";
say $headers.as-string;
# Accept: text/html
# Accept: text/*
# Accept: */*
# Content-Length: 42
```
By setting with a comma, you will generate multiple headers.
You may also set headers with <DateTime>, <Instant>, and <Duration> objects and it should do the right thing. For example,
```
$headers.header(Date) = DateTime.now;
$headers.header(Retry-After) = Duration.new(120);
say $headers.as-string;
# Date: Thu, 14 May 2015 09:48:00 GMT
# Retry-After: 120
```
When you read a header, the value returns is a [HTTP::Header](http::Header) object.
```
my HTTP::Header $ct = $headers.header(Content-Type);
my HTTP::Header $xf = $headers.header("X-Foo-Custom");
```
This object stringifies to the value of the header (with multiple values being joined together using a comma, safe according to RFC). It also provides a bunch of additional tools for working with and manipulating the header. For example:
```
$headers.header(Accept).push: "text/css", "text/js";
$headers.header(Content-Type).charset = "UTF-8";
```
See [HTTP::Header](http::Header) for details.
## method remove-header
```
multi method remove-header(HTTP::Header:D: $name --> HTTP::Header)
multi method remove-header(HTTP::Header:D: *@names --> List)
```
These method will remove headers from the list. The removed [HTTP::Header](http::Header) object is returned.
## method remove-content-headers
```
method remove-content-headers(HTTP::Headers:D: --> List)
```
This method removes all the entity headers:
```
Allow Content-Encoding Content-Language Content-Length
Content-Location Content-MD5 Content-Range Content-Type
Expires Last-Modified
```
as well as any that start with "Content-".
## method clear
```
method clear(HTTP::Headers:D:)
```
This removes all headers.
## method clone
```
method clone(HTTP::Headers:D: --> HTTP::Headers:D)
```
This performs a deep clone of the object.
## method sorted-headers
```
method sorted-headers(HTTP::Headers:D: --> Seq)
```
Returns all [HTTP::Header](http::Header) objcts in a sequence sorted by header name.
## method list
```
method list(HTTP::Headers:D: --> List)
```
This returns all the headers stored in this object, sorted according to the RFC recommendation (general headers first, then request/response headers, then entity/content headers, and finally custom headers).
## method map
```
method map(HTTP::Headers:D: &code --> Seq)
```
Provides a way to iterate over all the headers in the object.
## method as-string
```
method as-string(HTTP::Headers:D: Str:D :$eol = "\n" --> Str)
```
Returns the headers for output using the given line separator. If no line separator is given, "\n" is used.
## method Str
```
multi method Str(:$eol = "\n") returns Str
```
This calls [/method as-string](/method as-string) with the given arguments.
## method for-WAPI
```
method for-WAPI(HTTP::Headers:D: --> List:D)
```
This returns the headers formatted for output from a RakuWAPI application, as an array of Pairs.
# Hash-like Operations
You can also treat [HTTP::Headers](http::Headers) like a hash in some ways. These are **experimental** and might be removed or changed in the future.
## method postcircumfix:<{ }>
```
multi method postcircumfix:<{ }>(HTTP::Headers:D: Str:D $key --> HTTP::Header)
multi method postcircumfix:<{ }>(HTTP::Headers:D: HTTP::Header::Standard::Name:D $key --> HTTP::Header)
```
This may be used to return or assign a head value.
## adverb :delete
This may be used to delete headers.
## adverb :exists
This may be used to check to see if a head is set.
# Convenience Methods
The following methods are provided as a shortcut for [/method header](/method header) and can be used as an accessor or mutator.
```
# General Headers
method Cache-Control is rw
method Connection is rw
method Date is rw
method Pragma is rw
method Trailer is rw
method Transfer-Encoding is rw
method Upgrade is rw
method Via is rw
method Warning is rw
# Request Headers
method Accept is rw
method Accept-Charset is rw
method Accept-Encoding is rw
method Accept-Language is rw
method Authorization is rw
method Expect is rw
method From is rw
method Host is rw
method If-Match is rw
method If-Modified-Since is rw
method If-None-Match is rw
method If-Range is rw
method If-Unmodified-Since is rw
method Max-Forwards is rw
method Proxy-Authorization is rw
method Range is rw
method Referer is rw
method TE is rw
method User-Agent is rw
# Response Headers
method Accept-Ranges is rw
method Age is rw
method ETag is rw
method Location is rw
method Proxy-Authenticate is rw
method Retry-After is rw
method Server is rw
method Vary is rw
method WWW-Authenticate is rw
# Entity Headers
method Allow is rw
method Content-Encoding is rw
method Content-Language is rw
method Content-Length is rw
method Content-Location is rw
method Content-MD5 is rw
method Content-Range is rw
method Content-Type is rw
method Expires is rw
method Last-Modified is rw
```
# Extending HTTP::Headers
It is possible to create a sub-class of [HTTP::Headers](http::Headers) more suited to your application. As a simplistic example, here's a customization that provides two new custom headers named "X-Foo" and "X-Bar" which have a default column setting of 42 when used.
```
class MyApp::CustomHeaders is HTTP::Headers {
enum MyAppHeader < X-Foo X-Bar >;
method build-header($name, *@values) {
if $name ~~ MyAppHeader {
HTTP::Header::Custom.new(:name($name.Str), :42values);
}
else {
nextsame;
}
}
multi method header(MyAppHeader $name) is rw {
self.header-proxy($name);
}
method X-Foo is rw { self.header(MyAppHeader::X-Foo) }
method X-Bar is rw { self.header(MyAppHeader::X-Bar) }
}
```
Here is a description of the methods you'll need to consider in doing this.
## method build-header
```
multi method build-header(HTTP::Headers:D: Str:D $name, *@values --> HTTP::Header:D)
multi method build-header(HTTP::Headers:D: HTTP::Header::Standard::Name:D $name, *@values --> HTTP::Header:D)
```
This is a factory method used to decide how to build the headers being stored. Here is the place where you'll want to add custom roles to your headers, instantiate any custom implementations of [HTTP::Header](http::Header), etc.
It is recommended that you define it to build what you need and then use `nextsame` to handle all the remaining cases.
## method header-proxy
```
multi method header-proxy(HTTP::Headers:D: Str:D $name --> HTTP::Header) is rw
multi method header-proxy(HTTP::Headers:D: HTTP::Header::Standard::Name:D $name --> HTTP::Header) is rw
```
This is a handy helper that allows you to easily build your own custom version of [/method header](/method header). It returns a <Proxy> useful for building `is rw` methods similar to those in [HTTP::Headers](http::Headers).
# CAVEATS
This module provides a mutator style that is not considered ideal, possibly even un-Perlish. It pretty much completely overuses <Proxy> objects and such to make mutators that perform complex operations during seemingly straightforward assignment operations. This is probably not wise, but it seemed like a good idea at the time of first writing.
For a detailed write-up of why this is not preferable, see this blog post by Jonathan Worthington: [https://6guts.wordpress.com/2016/11/25/perl-6-is-biased-towards-mutators-being-really-simple-thats-a-good-thing/](Perl 6 is biased towards mutators being really simple. That’s a good thing.)
|
## trusting.md
role Metamodel::Trusting
Metaobject that supports trust relations between types
```raku
role Metamodel::Trusting is SuperClass { ... }
```
*Warning*: this role is part of the Rakudo implementation, and is not a part of the language specification.
Normally, code in a class or role can only access its own private methods. If another type declares that it trusts that first class, then access to private methods of that second type is possible. `Metamodel::Trusting` implements that aspect of the Raku object system.
```raku
class A {
my class B {
trusts A; # that's where Metamodel::Trusting comes in
method !private_method() {
say "Private method in B";
}
}
method build-and-poke {
# call a private method from B
# disallowed if A doesn't trust B
B.new()!B::private_method();
}
};
A.build-and-poke; # Private method in B
```
# [Methods](#role_Metamodel::Trusting "go to top of document")[§](#Methods "direct link")
## [method add\_trustee](#role_Metamodel::Trusting "go to top of document")[§](#method_add_trustee "direct link")
```raku
method add_trustee($type, Mu $trustee)
```
Trust `$trustee`.
```raku
class A {
BEGIN A.^add_trustee(B);
# same as 'trusts B';
}
```
## [method trusts](#role_Metamodel::Trusting "go to top of document")[§](#method_trusts "direct link")
```raku
method trusts($type --> List)
```
Returns a list of types that the invocant trusts.
```raku
class A { trusts Int; };
say .^name for A.^trusts; # Int
```
## [method is\_trusted](#role_Metamodel::Trusting "go to top of document")[§](#method_is_trusted "direct link")
```raku
method is_trusted($type, $claimant)
```
Returns 1 if `$type` trusts `$claimant`, and 0 otherwise. Types always trust themselves.
|
## dist_zef-FRITH-Math-Libgsl-BLAS.md
## Chunk 1 of 2
[](https://github.com/frithnanth/raku-Math-Libgsl-BLAS/actions)
# NAME
Math::Libgsl::BLAS - An interface to libgsl, the Gnu Scientific Library - BLAS (Basic Linear Algebra Subprograms).
# SYNOPSIS
```
use Math::Libgsl::Raw::BLAS :ALL;
use Math::Libgsl::BLAS;
use Math::Libgsl::BLAS::Num32;
use Math::Libgsl::BLAS::Complex32;
use Math::Libgsl::BLAS::Complex64;
```
# DESCRIPTION
Math::Libgsl::BLAS is an interface to the BLAS functions of the libgsl, the Gnu Scientific Library
This package provides both the low-level interface to the C library (Raw) and a more comfortable interface layer for the Raku programmer.
Throughout this package I used a naming convention corresponding to that of the C library, stripping the initial `gsl_blas_`.
The functions are divided in three levels:
* Level 1: vector operations
* Level 2: matrix-vector operations
* Level 3: matrix-matrix operations
The names of the functions specify the kind of operation, the matrix type, and the underlying data type. For more information please read the [C Library Documentation](C Library Documentation).
Since the original C library provided functions for four data types, so does this module. The Math::Libgsl::BLAS module provides functions that work on the default data type: num64. The functions working on num32 vector and matrices are in the Math::Libgsl::BLAS::Num32 module; those working on complex64 and complex32 are respectively in the Math::Libgsl::BLAS::Complex64 and Math::Libgsl::BLAS::Complex32 modules.
So for example this code will be executed using num32 data type variables:
```
use Math::Libgsl::Vector::Num32;
use Math::Libgsl::BLAS::Num32;
my $x = Math::Libgsl::Vector::Num32.new: 10;
$x.setall(.1);
my $y = Math::Libgsl::Vector::Num32.new: 10;
$y.setall(.2);
say sdsdot(.3, $x, $y); # output: 0.5
```
Here I'm following the order the functions are listed in the C Library Manual.
## Level 1
### sdsdot(Num() $α, Math::Libgsl::Vector::Num32 $x, Math::Libgsl::Vector::Num32 $y where { $y.vector.size == $x.vector.size } --> Num)
This function computes the sum α + T(x)y, where T(x) is the transpose of x.
### sdot(Math::Libgsl::Vector::Num32 $x, Math::Libgsl::Vector::Num32 $y where { $y.vector.size == $x.vector.size } --> Num)
### dsdot(Math::Libgsl::Vector::Num32 $x, Math::Libgsl::Vector::Num32 $y where { $y.vector.size == $x.vector.size } --> Num)
### ddot(Math::Libgsl::Vector $x, Math::Libgsl::Vector $y where { $y.vector.size == $x.vector.size } --> Num)
### cdotu(Math::Libgsl::Vector::Complex32 $x, Math::Libgsl::Vector::Complex32 $y where { $y.vector.size == $x.vector.size } --> Complex)
### zdotu(Math::Libgsl::Vector::Complex64 $x, Math::Libgsl::Vector::Complex64 $y where { $y.vector.size == $x.vector.size } --> Complex)
These functions compute the scalar product T(x)y.
### cdotc(Math::Libgsl::Vector::Complex32 $x, Math::Libgsl::Vector::Complex32 $y where { $y.vector.size == $x.vector.size } --> Complex)
### zdotc(Math::Libgsl::Vector::Complex64 $x, Math::Libgsl::Vector::Complex64 $y where { $y.vector.size == $x.vector.size } --> Complex)
These functions compute the complex conjugate scalar product H(x)y.
### snrm2(Math::Libgsl::Vector::Num32 $x --> Num)
### dnrm2(Math::Libgsl::Vector $x --> Num)
### scnrm2(Math::Libgsl::Vector::Complex32 $x --> Num)
### dznrm2(Math::Libgsl::Vector::Complex64 $x --> Num)
These functions compute the Euclidean norm ||x||₂.
### sasum(Math::Libgsl::Vector::Num32 $x --> Num)
### dasum(Math::Libgsl::Vector $x --> Num)
### scasum(Math::Libgsl::Vector::Complex32 $x --> Num)
### dzasum(Math::Libgsl::Vector::Complex64 $x --> Num)
These functions compute the absolute sum Σ|xᵢ| of the elements of the vector x (or the sum of the magnitudes of the real and imaginary parts).
### isamax(Math::Libgsl::Vector::Num32 $x --> Int)
### idamax(Math::Libgsl::Vector $x --> Int)
### icamax(Math::Libgsl::Vector::Complex32 $x --> Int)
### izamax(Math::Libgsl::Vector::Complex64 $x --> Int)
These functions return the index of the largest element of the vector x. The largest element is determined by its absolute magnitude for real vectors and by the sum of the magnitudes of the real and imaginary parts Σ|R(xᵢ)| + |I(xᵢ)| for complex vectors. If the largest value occurs several times then the index of the first occurrence is returned.
### sswap(Math::Libgsl::Vector::Num32 $x, Math::Libgsl::Vector::Num32 $y where { $y.vector.size == $x.vector.size } --> Int)
### dswap(Math::Libgsl::Vector $x, Math::Libgsl::Vector $y where { $y.vector.size == $x.vector.size } --> Int)
### cswap(Math::Libgsl::Vector::Complex32 $x, Math::Libgsl::Vector::Complex32 $y where { $y.vector.size == $x.vector.size } --> Int)
### zswap(Math::Libgsl::Vector::Complex64 $x, Math::Libgsl::Vector::Complex64 $y where { $y.vector.size == $x.vector.size } --> Int)
These functions exchange the elements of the vectors. These functions return GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
### scopy(Math::Libgsl::Vector::Num32 $x, Math::Libgsl::Vector::Num32 $y where { $y.vector.size == $x.vector.size } --> Int)
### dcopy(Math::Libgsl::Vector $x, Math::Libgsl::Vector $y where { $y.vector.size == $x.vector.size } --> Int)
### ccopy(Math::Libgsl::Vector::Complex32 $x, Math::Libgsl::Vector::Complex32 $y where { $y.vector.size == $x.vector.size } --> Int)
### zcopy(Math::Libgsl::Vector::Complex64 $x, Math::Libgsl::Vector::Complex64 $y where { $y.vector.size == $x.vector.size } --> Int)
These functions copy the elements of the vector x into the vector y. These functions return GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
### saxpy(Num() $α, Math::Libgsl::Vector::Num32 $x, Math::Libgsl::Vector::Num32 $y where { $y.vector.size == $x.vector.size } --> Int)
### daxpy(Num() $α, Math::Libgsl::Vector $x, Math::Libgsl::Vector $y where { $y.vector.size == $x.vector.size } --> Int)
### caxpy(Complex $α, Math::Libgsl::Vector::Complex32 $x, Math::Libgsl::Vector::Complex32 $y where { $y.vector.size == $x.vector.size } --> Int)
### zaxpy(Complex $α, Math::Libgsl::Vector::Complex64 $x, Math::Libgsl::Vector::Complex64 $y where { $y.vector.size == $x.vector.size } --> Int)
These functions compute the sum y = αx + y. These functions return GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
### sscal(Num() $α, Math::Libgsl::Vector::Num32 $x)
### dscal(Num() $α, Math::Libgsl::Vector $x)
### cscal(Complex $α, Math::Libgsl::Vector::Complex32 $x)
### zscal(Complex $α, Math::Libgsl::Vector::Complex64 $x)
### csscal(Num() $α, Math::Libgsl::Vector::Complex32 $x)
### zdscal(Num() $α, Math::Libgsl::Vector::Complex64 $x)
These functions rescale the vector x by α.
### srotg(Num() $a, Num() $b --> List)
### drotg(Num() $a, Num() $b --> List)
These functions compute a Givens rotation which zeroes the vector (a, b). They return the magnitude of the resulting vector and the coefficients (c, s) which zero the vector (a, b). In case of error a failure object is returned.
### srot(Math::Libgsl::Vector::Num32 $x, Math::Libgsl::Vector::Num32 $y where { $y.vector.size == $x.vector.size }, Num() $c, Num() $s --> Int)
### drot(Math::Libgsl::Vector $x, Math::Libgsl::Vector $y where { $y.vector.size == $x.vector.size }, Num() $c, Num() $s --> Int)
These functions apply a Givens rotation (x ′ , y ′ ) = (cx + sy, −sx + cy) to the vectors x, y. These functions return GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
### srotmg(Num() $d1, Num() $d2, Num() $b1, Num() $b2 --> List)
### drotmg(Num() $d1, Num() $d2, Num() $b1, Num() $b2 --> List)
These functions compute a modified Givens transformation. They return a list of five elements (see the BLAS manual for an explanation). In case of error a failure object is returned.
### srotm(Math::Libgsl::Vector::Num32 $x, Math::Libgsl::Vector::Num32 $y where { $y.vector.size == $x.vector.size }, @param where \*.elems == 5 --> Int)
### drotm(Math::Libgsl::Vector $x, Math::Libgsl::Vector $y where { $y.vector.size == $x.vector.size }, @param where \*.elems == 5 --> Int)
These functions apply a modified Givens transformation. These functions return GSL\_SUCCESS if successful, or one of the error codes (see the gsl-error enum in Math::Libgsl::Constants).
## Level 2
### sgemv(Int $TransA, Num() $α, Math::Libgsl::Matrix::Num32 $A, Math::Libgsl::Vector::Num32 $x, Num() $β, Math::Libgsl::Vector::Num32 $y --> Int)
### dgemv(Int $TransA, Num() $α, Math::Libgsl::Matrix $A, Math::Libgsl::Vector $x, Num() $β, Math::Libgsl::Vector $y --> Int)
### cgemv(Int $TransA, Complex $α, Math::Libgsl::Matrix::Complex32 $A, Math::Libgsl::Vector::Complex32 $x, Complex $β, Math::Libgsl::Vector::Complex32 $y --> Int)
### zgemv(Int $TransA, Complex $α, Math::Libgsl::Matrix::Complex64 $A, Math::Libgsl::Vector::Complex64 $x, Complex $β, Math::Libgsl::Vector::Complex64 $y --> Int)
These functions compute the matrix-vector product and sum y = αop(A)x + βy. "op" can be a no-op, a transpose, or a hermitian transpose (see the cblas-transpose enum in Math::Libgsl::Constants). These functions return GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
### strmv(Int $Uplo, Int $TransA, Int $Diag, Math::Libgsl::Matrix::Num32 $A, Math::Libgsl::Vector::Num32 $x --> Int)
### dtrmv(Int $Uplo, Int $TransA, Int $Diag, Math::Libgsl::Matrix $A, Math::Libgsl::Vector $x --> Int)
### ctrmv(Int $Uplo, Int $TransA, Int $Diag, Math::Libgsl::Matrix::Complex32 $A, Math::Libgsl::Vector::Complex32 $x --> Int)
### ztrmv(Int $Uplo, Int $TransA, Int $Diag, Math::Libgsl::Matrix::Complex64 $A, Math::Libgsl::Vector::Complex64 $x --> Int)
These functions compute the matrix-vector product x = op(A)x for the triangular matrix A. "op" can be a no-op, a transpose, or a hermitian transpose (see the cblas-transpose enum in Math::Libgsl::Constants). When Uplo is CblasUpper then the upper triangle of A is used, and when Uplo is CblasLower then the lower triangle of A is used. If Diag is CblasNonUnit then the diagonal of the matrix is used, but if Diag is CblasUnit then the diagonal elements of the matrix A are taken as unity and are not referenced (see the cblas-uplo and cblas-diag enums in Math::Libgsl::Constants). These functions return GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
### strsv(Int $Uplo, Int $TransA, Int $Diag, Math::Libgsl::Matrix::Num32 $A, Math::Libgsl::Vector::Num32 $x --> Int)
### dtrsv(Int $Uplo, Int $TransA, Int $Diag, Math::Libgsl::Matrix $A, Math::Libgsl::Vector $x --> Int)
### ctrsv(Int $Uplo, Int $TransA, Int $Diag, Math::Libgsl::Matrix::Complex32 $A, Math::Libgsl::Vector::Complex32 $x --> Int)
### ztrsv(Int $Uplo, Int $TransA, Int $Diag, Math::Libgsl::Matrix::Complex64 $A, Math::Libgsl::Vector::Complex64 $x --> Int)
These functions compute inv(op(A))x for x. "op" can be a no-op, a transpose, or a hermitian transpose (see the cblas-transpose enum in Math::Libgsl::Constants). When Uplo is CblasUpper then the upper triangle of A is used, and when Uplo is CblasLower then the lower triangle of A is used. If Diag is CblasNonUnit then the diagonal of the matrix is used, but if Diag is CblasUnit then the diagonal elements of the matrix A are taken as unity and are not referenced (see the cblas-uplo and cblas-diag enums in Math::Libgsl::Constants). These functions return GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
### ssymv(Int $Uplo, Num() $α, Math::Libgsl::Matrix::Num32 $A, Math::Libgsl::Vector::Num32 $x, Num() $β, Math::Libgsl::Vector::Num32 $y --> Int)
### dsymv(Int $Uplo, Num() $α, Math::Libgsl::Matrix $A, Math::Libgsl::Vector $x, Num() $β, Math::Libgsl::Vector $y --> Int)
These functions compute the matrix-vector product and sum y = αAx + βy for the symmetric matrix A. Since the matrix A is symmetric only its upper half or lower half need to be stored. When Uplo is CblasUpper then the upper triangle and diagonal of A are used, and when Uplo is CblasLower then the lower triangle and diagonal of A are used (see the cblas-uplo enum in Math::Libgsl::Constants). These functions return GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
### chemv(Int $Uplo, Complex $α, Math::Libgsl::Matrix::Complex32 $A, Math::Libgsl::Vector::Complex32 $x, Complex $β, Math::Libgsl::Vector::Complex32 $y --> Int)
### zhemv(Int $Uplo, Complex $α, Math::Libgsl::Matrix::Complex64 $A, Math::Libgsl::Vector::Complex64 $x, Complex $β, Math::Libgsl::Vector::Complex64 $y --> Int)
These functions compute the matrix-vector product and sum y = αAx + βy for the hermitian matrix A. Since the matrix A is hermitian only its upper half or lower half need to be stored. When Uplo is CblasUpper then the upper triangle and diagonal of A are used, and when Uplo is CblasLower then the lower triangle and diagonal of A are used (see the cblas-uplo enum in Math::Libgsl::Constants). The imaginary elements of the diagonal are automatically assumed to be zero and are not referenced. These functions return GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
### sger(Num() $α, Math::Libgsl::Vector::Num32 $x, Math::Libgsl::Vector::Num32 $y, Math::Libgsl::Matrix::Num32 $A --> Int)
### dger(Num() $α, Math::Libgsl::Vector $x, Math::Libgsl::Vector $y, Math::Libgsl::Matrix $A --> Int)
### cgeru(Complex $α, Math::Libgsl::Vector::Complex32 $x, Math::Libgsl::Vector::Complex32 $y, Math::Libgsl::Matrix::Complex32 $A --> Int)
### zgeru(Complex $α, Math::Libgsl::Vector::Complex64 $x, Math::Libgsl::Vector::Complex64 $y, Math::Libgsl::Matrix::Complex64 $A --> Int)
These functions compute the rank-1 update A = αxy T + A of the matrix A. These functions return GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
### cgerc(Complex $α, Math::Libgsl::Vector::Complex32 $x, Math::Libgsl::Vector::Complex32 $y, Math::Libgsl::Matrix::Complex32 $A --> Int)
### zgerc(Complex $α, Math::Libgsl::Vector::Complex64 $x, Math::Libgsl::Vector::Complex64 $y, Math::Libgsl::Matrix::Complex64 $A --> Int)
These functions compute the conjugate rank-1 update A = αxH(y) + A of the matrix A. These functions return GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
### ssyr(Int $Uplo, Num() $α, Math::Libgsl::Vector::Num32 $x, Math::Libgsl::Matrix::Num32 $A --> Int)
### dsyr(Int $Uplo, Num() $α, Math::Libgsl::Vector $x, Math::Libgsl::Matrix $A --> Int)
These functions compute the symmetric rank-1 update A = αxT(x) + A of the symmetric matrix A. Since the matrix A is symmetric only its upper half or lower half need to be stored. When Uplo is CblasUpper then the upper triangle and diagonal of A are used, and when Uplo is CblasLower then the lower triangle and diagonal of A are used (see the cblas-uplo enum in Math::Libgsl::Constants). These functions return GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
### cher(Int $Uplo, num32 $α, Math::Libgsl::Vector::Complex32 $x, Math::Libgsl::Matrix::Complex32 $A --> Int)
### zher(Int $Uplo, num64 $α, Math::Libgsl::Vector::Complex64 $x, Math::Libgsl::Matrix::Complex64 $A --> Int)
These functions compute the hermitian rank-1 update A = αxx H + A of the hermitian matrix A. Since the matrix A is hermitian only its upper half or lower half need to be stored. When Uplo is CblasUpper then the upper triangle and diagonal of A are used, and when Uplo is CblasLower then the lower triangle and diagonal of A are used (see the cblas-uplo enum in Math::Libgsl::Constants). The imaginary elements of the diagonal are automatically set to zero. These functions return GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
### ssyr2(Int $Uplo, Num() $α, Math::Libgsl::Vector::Num32 $x, Math::Libgsl::Vector::Num32 $y, Math::Libgsl::Matrix::Num32 $A --> Int)
### dsyr2(Int $Uplo, Num() $α, Math::Libgsl::Vector $x, Math::Libgsl::Vector $y, Math::Libgsl::Matrix $A --> Int)
These functions compute the symmetric rank-2 update A = αxT(y) + αyT(x) + A of the symmetric matrix A. Since the matrix A is symmetric only its upper half or lower half need to be stored. When Uplo is CblasUpper then the upper triangle and diagonal of A are used, and when Uplo is CblasLower then the lower triangle and diagonal of A are used (see the cblas-uplo enum in Math::Libgsl::Constants). These functions return GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
### cher2(Int $Uplo, Complex $α, Math::Libgsl::Vector::Complex32 $x, Math::Libgsl::Vector::Complex32 $y, Math::Libgsl::Matrix::Complex32 $A --> Int)
### zher2(Int $Uplo, Complex $α, Math::Libgsl::Vector::Complex64 $x, Math::Libgsl::Vector::Complex64 $y, Math::Libgsl::Matrix::Complex64 $A --> Int)
These functions compute the hermitian rank-2 update A = αxH(y) + α \* yH(x) + A of the hermitian matrix A. Since the matrix A is hermitian only its upper half or lower half need to be stored. When Uplo is CblasUpper then the upper triangle and diagonal of A are used, and when Uplo is CblasLower then the lower triangle and diagonal of A are used (see the cblas-uplo enum in Math::Libgsl::Constants). The imaginary elements of the diagonal are automatically set to zero. These functions return GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
## Level 3
### sgemm(Int $TransA, Int $TransB, Num() $α, Math::Libgsl::Matrix::Num32 $A, Math::Libgsl::Matrix::Num32 $B, Num() $β, Math::Libgsl::Matrix::Num32 $C --> Int)
### dgemm(Int $TransA, Int $TransB, Num() $α, Math::Libgsl::Matrix $A, Math::Libgsl::Matrix $B, Num() $β, Math::Libgsl::Matrix $C --> Int)
### cgemm(Int $TransA, Int $TransB, Complex $α, Math::Libgsl::Matrix::Complex32 $A, Math::Libgsl::Matrix::Complex32 $B, Complex $β, Math::Libgsl::Matrix::Complex32 $C --> Int)
### zgemm(Int $TransA, Int $TransB, Complex $α, Math::Libgsl::Matrix::Complex64 $A, Math::Libgsl::Matrix::Complex64 $B, Complex $β, Math::Libgsl::Matrix::Complex64 $C --> Int)
These functions compute the matrix-matrix product and sum C = αop(A)op(B) + βC where op(A) = A, T(A), H(A) for TransA = CblasNoTrans, CblasTrans, CblasConjTrans and similarly for the parameter TransB (see the cblas-transpose enum in Math::Libgsl::Constants). These functions return GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
### ssymm(Int $Side, Int $Uplo, Num() $α, Math::Libgsl::Matrix::Num32 $A, Math::Libgsl::Matrix::Num32 $B, Num() $β, Math::Libgsl::Matrix::Num32 $C --> Int)
### dsymm(Int $Side, Int $Uplo, Num() $α, Math::Libgsl::Matrix $A, Math::Libgsl::Matrix $B, Num() $β, Math::Libgsl::Matrix $C --> Int)
### csymm(Int $Side, Int $Uplo, Complex $α, Math::Libgsl::Matrix::Complex32 $A, Math::Libgsl::Matrix::Complex32 $B, Complex $β, Math::Libgsl::Matrix::Complex32 $C --> Int)
### zsymm(Int $Side, Int $Uplo, Complex $α, Math::Libgsl::Matrix::Complex64 $A, Math::Libgsl::Matrix::Complex64 $B, Complex $β, Math::Libgsl::Matrix::Complex64 $C --> Int)
These functions compute the matrix-matrix product and sum C = αAB + βC for Side is CblasLeft and C = αBA + βC for Side is CblasRight, where the matrix A is symmetric (see the cblas-side enum in Math::Libgsl::Constants). When Uplo is CblasUpper then the upper triangle and diagonal of A are used, and when Uplo is CblasLower then the lower triangle and diagonal of A are used (see the cblas-uplo enum in Math::Libgsl::Constants). These functions return GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
### chemm(Int $Side, Int $Uplo, Complex $α, Math::Libgsl::Matrix::Complex32 $A, Math::Libgsl::Matrix::Complex32 $B, Complex $β, Math::Libgsl::Matrix::Complex32 $C --> Int)
### zhemm(Int $Side, Int $Uplo, Complex $α, Math::Libgsl::Matrix::Complex64 $A, Math::Libgsl::Matrix::Complex64 $B, Complex $β, Math::Libgsl::Matrix::Complex64 $C --> Int)
These functions compute the matrix-matrix product and sum C = αAB + βC for Side is CblasLeft and C = αBA + βC for Side is CblasRight, where the matrix A is hermitian (see the cblas-side enum in Math::Libgsl::Constants). When Uplo is CblasUpper then the upper triangle and diagonal of A are used, and when Uplo is CblasLower then the lower triangle and diagonal of A are used (see the cblas-uplo enum in Math::Libgsl::Constants). The imaginary elements of the diagonal are automatically set to zero. These functions return GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
### strmm(Int $Side, Int $Uplo, Int $TransA, Int $Diag, Num() $α, Math::Libgsl::Matrix::Num32 $A, Math::Libgsl::Matrix::Num32 $B --> Int)
### dtrmm(Int $Side, Int $Uplo, Int $TransA, Int $Diag, Num() $α, Math::Libgsl::Matrix $A, Math::Libgsl::Matrix $B --> Int)
### ctrmm(Int $Side, Int $Uplo, Int $TransA, Int $Diag, Complex $α, Math::Libgsl::Matrix::Complex32 $A, Math::Libgsl::Matrix::Complex32 $B --> Int)
### ztrmm(Int $Side, Int $Uplo, Int $TransA, Int $Diag, Complex $α, Math::Libgsl::Matrix::Complex64 $A, Math::Libgsl::Matrix::Complex64 $B --> Int)
These functions compute the matrix-matrix product B = αop(A)B for Side is CblasLeft and B = αBop(A) for Side is CblasRight (see the cblas-side enum in Math::Libgsl::Constants). The matrix A is triangular and op(A) = A, T(A), H(A) for TransA = CblasNoTrans, CblasTrans, CblasConjTrans (see the cblas-transpose enum in Math::Libgsl::Constants). When Uplo is CblasUpper then the upper triangle of A is used, and when Uplo is CblasLower then the lower triangle of A is used (see the cblas-uplo enum in Math::Libgsl::Constants). If Diag is CblasNonUnit then the diagonal of A is used, but if Diag is CblasUnit then the diagonal elements of the matrix A are taken as unity and are not referenced (see cblas-diag enums in Math::Libgsl::Constants). These functions return GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
### strsm(Int $Side, Int $Uplo, Int $TransA, Int $Diag, Num() $α, Math::Libgsl::Matrix::Num32 $A, Math::Libgsl::Matrix::Num32 $B --> Int)
### dtrsm(Int $Side, Int $Uplo, Int $TransA, Int $Diag, Num() $α, Math::Libgsl::Matrix $A, Math::Libgsl::Matrix $B --> Int)
### ctrsm(Int $Side, Int $Uplo, Int $TransA, Int $Diag, Complex $α, Math::Libgsl::Matrix::Complex32 $A, Math::Libgsl::Matrix::Complex32 $B --> Int)
### ztrsm(Int $Side, Int $Uplo, Int $TransA, Int $Diag, Complex $α, Math::Libgsl::Matrix::Complex64 $A, Math::Libgsl::Matrix::Complex64 $B --> Int)
These functions compute the inverse-matrix matrix product B = αop(inv(A))B for Side is CblasLeft and B = αBop(inv(A)) for Side is CblasRight (see the cblas-side enum in Math::Libgsl::Constants). The matrix A is triangular and op(A) = A, T(A), H(A) for TransA = CblasNoTrans, CblasTrans, CblasConjTrans (see the cblas-transpose enum in Math::Libgsl::Constants). When Uplo is CblasUpper then the upper triangle of A is used, and when Uplo is CblasLower then the lower triangle of A is used (see the cblas-uplo enum in Math::Libgsl::Constants). If Diag is CblasNonUnit then the diagonal of A is used, but if Diag is CblasUnit then the diagonal elements of the matrix A are taken as unity and are not referenced (see cblas-diag enums in Math::Libgsl::Constants). These functions return GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
### ssyrk(Int $Uplo, Int $TransA, Num() $α, Math::Libgsl::Matrix::Num32 $A, Num() $β, Math::Libgsl::Matrix::Num32 $C --> Int)
### dsyrk(Int $Uplo, Int $TransA, Num() $α, Math::Libgsl::Matrix $A, Num() $β, Math::Libgsl::Matrix $C --> Int)
### csyrk(Int $Uplo, Int $TransA, Complex $α, Math::Libgsl::Matrix::Complex32 $A, Complex $β, Math::Libgsl::Matrix::Complex32 $C --> Int)
### zsyrk(Int $Uplo, Int $TransA, Complex $α, Math::Libgsl::Matrix::Complex64 $A, Complex $β, Math::Libgsl::Matrix::Complex64 $C --> Int)
These functions compute a rank-k update of the symmetric matrix C, C = αAT(A) + βC when Trans is CblasNoTrans and C = αT(A)A + βC when Trans is CblasTrans (see the cblas-transpose enum in Math::Libgsl::Constants). Since the matrix C is symmetric only its upper half or lower half need to be stored. When Uplo is CblasUpper then the upper triangle and diagonal of C are used, and when Uplo is CblasLower then the lower triangle and diagonal of C are used (see the cblas-uplo enum in Math::Libgsl::Constants). These functions return GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
### cherk(Int $Uplo, Int $TransA, num32 $α, Math::Libgsl::Matrix::Complex32 $A, num32 $β, Math::Libgsl::Matrix::Complex32 $C --> Int)
### zherk(Int $Uplo, Int $TransA, num64 $α, Math::Libgsl::Matrix::Complex64 $A, num64 $β, Math::Libgsl::Matrix::Complex64 $C --> Int)
These functions compute a rank-k update of the hermitian matrix C, C = αAH(A) + βC when Trans is CblasNoTrans and C = αH(A)A + βC when Trans is CblasConjTrans (see the cblas-transpose enum in Math::Libgsl::Constants). Since the matrix C is hermitian only its upper half or lower half need to be stored. When Uplo is CblasUpper then the upper triangle and diagonal of C are used, and when Uplo is CblasLower then the lower triangle and diagonal of C are used (see the cblas-uplo enum in Math::Libgsl::Constants). The imaginary elements of the diagonal are automatically set to zero. These functions return GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
### ssyr2k(Int $Uplo, Int $TransA, Num() $α, Math::Libgsl::Matrix::Num32 $A, Math::Libgsl::Matrix::Num32 $B, Num() $β, |
## dist_zef-FRITH-Math-Libgsl-BLAS.md
## Chunk 2 of 2
Math::Libgsl::Matrix::Num32 $C --> Int)
### dsyr2k(Int $Uplo, Int $TransA, Num() $α, Math::Libgsl::Matrix $A, Math::Libgsl::Matrix $B, Num() $β, Math::Libgsl::Matrix $C --> Int)
### csyr2k(Int $Uplo, Int $TransA, Complex $α, Math::Libgsl::Matrix::Complex32 $A, Math::Libgsl::Matrix::Complex32 $B, Complex $β, Math::Libgsl::Matrix::Complex32 $C --> Int)
### zsyr2k(Int $Uplo, Int $TransA, Complex $α, Math::Libgsl::Matrix::Complex64 $A, Math::Libgsl::Matrix::Complex64 $B, Complex $β, Math::Libgsl::Matrix::Complex64 $C --> Int)
These functions compute a rank-2k update of the symmetric matrix C, C = αAT(B) + αBT(A) + βC when Trans is CblasNoTrans and C = αT(A)B + αT(B)A + βC when Trans is CblasTrans (see the cblas-transpose enum in Math::Libgsl::Constants). Since the matrix C is symmetric only its upper half or lower half need to be stored. When Uplo is CblasUpper then the upper triangle and diagonal of C are used, and when Uplo is CblasLower then the lower triangle and diagonal of C are used (see the cblas-uplo enum in Math::Libgsl::Constants). These functions return GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
### cher2k(Int $Uplo, Int $TransA, Complex $α, Math::Libgsl::Matrix::Complex32 $A, Math::Libgsl::Matrix::Complex32 $B, num32 $β, Math::Libgsl::Matrix::Complex32 $C --> Int)
### zher2k(Int $Uplo, Int $TransA, Complex $α, Math::Libgsl::Matrix::Complex64 $A, Math::Libgsl::Matrix::Complex64 $B, num64 $β, Math::Libgsl::Matrix::Complex64 $C --> Int)
These functions compute a rank-2k update of the hermitian matrix C, C = αAH(B) + conj(α)BH(A) + βC when Trans is CblasNoTrans and C = αH(A)B + conj(α)H(B)A + βC when Trans is CblasConjTrans (see the cblas-transpose enum in Math::Libgsl::Constants). Since the matrix C is hermitian only its upper half or lower half need to be stored. When Uplo is CblasUpper then the upper triangle and diagonal of C are used, and when Uplo is CblasLower then the lower triangle and diagonal of C are used (see the cblas-uplo enum in Math::Libgsl::Constants). The imaginary elements of the diagonal are automatically set to zero. These functions return GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
# C Library Documentation
For more details on libgsl see <https://www.gnu.org/software/gsl/>.
The excellent C Library manual is available here <https://www.gnu.org/software/gsl/doc/html/index.html>, or here <https://www.gnu.org/software/gsl/doc/latex/gsl-ref.pdf> in PDF format.
The BLAS C Library manual is available here <https://software.intel.com/en-us/mkl-developer-reference-c-blas-routines> and here <http://netlib.org/blas/#_level_1>.
# Prerequisites
This module requires the libgsl library to be installed. Please follow the instructions below based on your platform:
## Debian Linux
```
sudo apt install libgsl23 libgsl-dev libgslcblas0
```
That command will install libgslcblas0 as well, since it's used by the GSL.
## Ubuntu 18.04 and Ubuntu 20.04+
libgsl23 and libgslcblas0 have a missing symbol on Ubuntu 18.04. I solved the issue installing the Debian Buster version of those three libraries:
* <http://http.us.debian.org/debian/pool/main/g/gsl/libgslcblas0_2.5+dfsg-6_amd64.deb>
* <http://http.us.debian.org/debian/pool/main/g/gsl/libgsl23_2.5+dfsg-6_amd64.deb>
* <http://http.us.debian.org/debian/pool/main/g/gsl/libgsl-dev_2.5+dfsg-6_amd64.deb>
# Installation
To install it using zef (a module management tool):
```
$ zef install Math::Libgsl::BLAS
```
# AUTHOR
Fernando Santagata [nando.santagata@gmail.com](mailto:nando.santagata@gmail.com)
# COPYRIGHT AND LICENSE
Copyright 2020 Fernando Santagata
This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.
|
## trim-leading.md
trim-leading
Combined from primary sources listed below.
# [In Allomorph](#___top "go to top of document")[§](#(Allomorph)_method_trim-leading "direct link")
See primary documentation
[in context](/type/Allomorph#method_trim-leading)
for **method trim-leading**.
```raku
method trim-leading(Allomorph:D:)
```
Calls [`Str.trim-leading`](/type/Str#method_trim-leading) on the invocant's [`Str`](/type/Str) value.
# [In Str](#___top "go to top of document")[§](#(Str)_method_trim-leading "direct link")
See primary documentation
[in context](/type/Str#method_trim-leading)
for **method trim-leading**.
```raku
method trim-leading(Str:D: --> Str)
```
Removes the whitespace characters from the beginning of a string. See also [trim](/routine/trim).
# [In Cool](#___top "go to top of document")[§](#(Cool)_routine_trim-leading "direct link")
See primary documentation
[in context](/type/Cool#routine_trim-leading)
for **routine trim-leading**.
```raku
sub trim-leading(Str(Cool))
method trim-leading()
```
Coerces the invocant (or in sub form, its argument) to [`Str`](/type/Str), and returns the string with leading whitespace stripped.
```raku
my $stripped = ' abc '.trim-leading;
say "<$stripped>"; # OUTPUT: «<abc >»
```
|
## dist_cpan-HOLLI-Color-Scheme.md
# NAME
Color::Scheme - Generate color schemes from a base color
# SYNOPSIS
```
use Color::Scheme;
my $color = Color.new( "#1A3CFA" );
# this is the sugar
my @palette = color-scheme( $color, 'six-tone-ccw' );
# for this
my @palette = color-scheme( $color, color-scheme-angles<six-tone-ccw> );
# debug flag, to visually inspect the colors
# creates "colors.html" in the current directory
my @palette = color-scheme( $color, 'triadic', :debug );
```
# DESCRIPTION
With Color::Scheme you can create schemes/palettes of colors that work well together.
You pick a base color and one of sixteen schemes and the module will generate a list of colors that harmonize. How many colors depends on the scheme.
There are 16 schemes available:
* split-complementary (3 colors)
* split-complementary-cw (3 colors)
* split-complementary-ccw (3 colors)
* triadic (3 colors)
* clash (3 colors)
* tetradic (4 colors)
* four-tone-cw (4 colors)
* four-tone-ccw (4 colors)
* five-tone-a (5 colors)
* five-tone-b (5 colors)
* five-tone-cs (5 colors)
* five-tone-ds (5 colors)
* five-tone-es (5 colors)
* analogous (6 colors)
* neutral (6 colors)
* six-tone-ccw (6 colors)
* six-tone-cw (6 colors)
Those schemes are just lists of angles in a hash ( `Color::Scheme::color-scheme-angles`).
You can use the second form of the color-scheme sub to pass in your own angles if you have to.
# AUTHOR
```
holli.holzer@gmail.com
```
# COPYRIGHT AND LICENSE
BSD-3 License (see LICENSE file)
This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law.
|
## io-guide.md
Input/Output the definitive guide
Correctly use Raku IO
# [The basics](#Input/Output_the_definitive_guide "go to top of document")[§](#The_basics "direct link")
The vast majority of common IO work is done by the [`IO::Path`](/type/IO/Path) type. If you want to read from or write to a file in some form or shape, this is the class you want. It abstracts away the details of filehandles (or "file descriptors") and so you mostly don't even have to think about them.
Behind the scenes, [`IO::Path`](/type/IO/Path) works with [`IO::Handle`](/type/IO/Handle), a class which you can use directly if you need a bit more control than what [`IO::Path`](/type/IO/Path) provides. When working with other processes, e.g. via [`Proc`](/type/Proc) or [`Proc::Async`](/type/Proc/Async) types, you'll also be dealing with a *subclass* of [`IO::Handle`](/type/IO/Handle): the [`IO::Pipe`](/type/IO/Pipe).
Lastly, you have the [`IO::CatHandle`](/type/IO/CatHandle), as well as [`IO::Spec`](/type/IO/Spec) and its subclasses, that you'll rarely, if ever, use directly. These classes give you advanced features, such as operating on multiple files as one handle, or low-level path manipulations.
Along with all these classes, Raku provides several subroutines that let you indirectly work with these classes. These come in handy if you like functional programming style or in Raku one liners.
While [`IO::Socket`](/type/IO/Socket) and its subclasses also have to do with Input and Output, this guide does not cover them.
# [Navigating paths](#Input/Output_the_definitive_guide "go to top of document")[§](#Navigating_paths "direct link")
## [What's an IO::Path anyway?](#Input/Output_the_definitive_guide "go to top of document")[§](#What's_an_IO::Path_anyway? "direct link")
To represent paths as either files or directories, use [`IO::Path`](/type/IO/Path) type. The simplest way to obtain an object of that type is to coerce a [`Str`](/type/Str) by calling the [`.IO`](/routine/IO) method on it:
```raku
say 'my-file.txt'.IO; # OUTPUT: «"my-file.txt".IO»
```
It may seem like something is missing here—there is no volume or absolute path involved—but that information is actually present in the object. You can see it by using [`.raku`](/routine/raku) method:
```raku
say 'my-file.txt'.IO.raku;
# OUTPUT: «IO::Path.new("my-file.txt", :SPEC(IO::Spec::Unix), :CWD("/home/camelia"))»
```
The two extra attributes—`SPEC` and `CWD`—specify what type of operating system semantics the path should use as well as the "current working directory" for the path, i.e. if it's a relative path, then it's relative to that directory.
This means that regardless of how you made one, an [`IO::Path`](/type/IO/Path) object technically always refers to an absolute path. This is why its [`.absolute`](/routine/absolute) and [`.relative`](/routine/relative) methods return [`Str`](/type/Str) objects and they are the correct way to stringify a path.
However, don't be in a rush to stringify anything. Pass paths around as [`IO::Path`](/type/IO/Path) objects. All the routines that operate on paths can handle them, so there's no need to convert them.
## [Path parts](#Input/Output_the_definitive_guide "go to top of document")[§](#Path_parts "direct link")
Given a local file name, it's very easy to get its components. For example, we have a file, "financial.data", in some directory, "/usr/local/data". Use Raku to analyze its path:
```raku
my $fname = "financial.data";
# Stringify the full path name
my $f = $fname.IO.absolute;
say $f;
# OUTPUT: «/usr/local/data/financial.data»
# Stringify the path's parts:
say $f.IO.dirname; # OUTPUT: «/usr/local/data»
say $f.IO.basename; # OUTPUT: «financial.data»
# And the basename's parts:
# Use a method for the extension:
say $f.IO.extension; # OUTPUT: «data»
# Remove the extension by redefining it:
say ($f.IO.extension("")).IO.basename; # OUTPUT: «financial»
```
## [Working with files](#Input/Output_the_definitive_guide "go to top of document")[§](#Working_with_files "direct link")
### [Writing into files](#Input/Output_the_definitive_guide "go to top of document")[§](#Writing_into_files "direct link")
#### [Writing new content](#Input/Output_the_definitive_guide "go to top of document")[§](#Writing_new_content "direct link")
Let's make some files and write and read data from them! The [`spurt`](/routine/spurt) and [`slurp`](/routine/slurp) routines write and read the data in one chunk respectively. Unless you're working with very large files that are difficult to store entirely in memory all at the same time, these two routines are for you.
```raku
"my-file.txt".IO.spurt: "I ♥ Raku!";
```
The code above creates a file named `my-file.txt` in the current directory and then writes text `I ♥ Raku!` into it. If Raku is your first language, celebrate your accomplishment! Try to open the file you created with a text editor to verify what you wrote with your program. If you already know some other language, you may be wondering if this guide missed anything like handling encoding or error conditions.
However, that is all the code you need. The string will be encoded in `utf-8` encoding by default and the errors are handled via the [`Failure`](/type/Failure) mechanism: these are exceptions you can handle using regular conditionals. In this case, we're letting all potential [`Failure`](/type/Failure)s get sunk after the call and so any [`Exceptions`](/type/Exception) they contain will be thrown.
#### [Appending content](#Input/Output_the_definitive_guide "go to top of document")[§](#Appending_content "direct link")
If you wanted to add more content to the file we created in the previous section, you could note the [`spurt` documentation](/routine/spurt) mentions `:append` as one of its argument options. However, for finer control, let's get ourselves an [`IO::Handle`](/type/IO/Handle) to work with:
```raku
my $fh = 'my-file.txt'.IO.open: :a;
$fh.print: "I count: ";
$fh.print: "$_ " for ^10;
$fh.close;
```
The [`.open`](/routine/open) method call opens our [`IO::Path`](/type/IO/Path) and returns an [`IO::Handle`](/type/IO/Handle). We passed `:a` as argument, to indicate we want to open the file for writing in append mode.
In the next two lines of code, we use the usual [`.print`](/routine/print) method on that [`IO::Handle`](/type/IO/Handle) to print a line with 11 pieces of text (the `'I count: '` string and 10 numbers). Note that, once again, [`Failure`](/type/Failure) mechanism takes care of all the error checking for us. If the [`.open`](/routine/open) fails, it returns a [`Failure`](/type/Failure), which will throw when we attempt to call method the [`.print`](/routine/print) on it.
Finally, we close the [`IO::Handle`](/type/IO/Handle) by calling the [`.close`](/routine/close) method on it. It is *important that you do it*, especially in large programs or ones that deal with a lot of files, as many systems have limits to how many files a program can have open at the same time. If you don't close your handles, eventually you'll reach that limit and the [`.open`](/routine/open) call will fail. Note that unlike some other languages, Raku does not use reference counting, so the filehandles **are NOT closed** when the scope they're defined in is left. They will be closed only when they're garbage collected and failing to close the handles may cause your program to reach the file limit *before* the open handles get a chance to get garbage collected.
### [Reading from files](#Input/Output_the_definitive_guide "go to top of document")[§](#Reading_from_files "direct link")
#### [Using IO::Path](#Input/Output_the_definitive_guide "go to top of document")[§](#Using_IO::Path "direct link")
We've seen in previous sections that writing stuff to files is a single-line of code in Raku. Reading from them, is similarly easy:
```raku
say 'my-file.txt'.IO.slurp; # OUTPUT: «I ♥ Raku!»
say 'my-file.txt'.IO.slurp: :bin; # OUTPUT: «Buf[uint8]:0x<49 20 E2 99 A5 20 52 61 6B 75 21>»
```
The [`.slurp`](/routine/slurp) method reads entire contents of the file and returns them as a single [`Str`](/type/Str) object, or as a [`Buf`](/type/Buf) object, if binary mode was requested, by specifying `:bin` named argument.
Since [slurping](/routine/slurp) loads the entire file into memory, it's not ideal for working with huge files.
The [`IO::Path`](/type/IO/Path) type offers two other handy methods: [`.words`](/type/IO/Path#method_words) and [`.lines`](/type/IO/Path#method_lines) that lazily read the file in smaller chunks and return [`Seq`](/type/Seq) objects that (by default) don't keep already-consumed values around.
Here's an example that finds lines in a text file that mention Raku and prints them out. Despite the file itself being too large to fit into available [RAM](https://en.wikipedia.org/wiki/Random-access_memory), the program will not have any issues running, as the contents are processed in small chunks:
```raku
.say for '500-PetaByte-File.txt'.IO.lines.grep: *.contains: 'Raku';
```
Here's another example that prints the first 100 words from a file, without loading it entirely:
```raku
.say for '500-PetaByte-File.txt'.IO.words: 100
```
Note that we did this by passing a limit argument to [`.words`](/type/IO/Path#method_words) instead of, say, using [a list indexing operation](/language/operators#index-entry-array_indexing_operator-array_subscript_operator-array_indexing_operator). The reason for that is there's still a filehandle in use under the hood, and until you fully consume the returned [`Seq`](/type/Seq), the handle will remain open. If nothing references the [`Seq`](/type/Seq), eventually the handle will get closed, during a garbage collection run, but in large programs that work with a lot of files, it's best to ensure all the handles get closed right away. So, you should always ensure the [`Seq`](/type/Seq) from [`IO::Path`](/type/IO/Path)'s [`.words`](/type/IO/Path#method_words) and [`.lines`](/type/IO/Path#method_lines) methods is [fully reified](/language/glossary#Reify); and the limit argument is there to help you with that.
#### [Using IO::Handle](#Input/Output_the_definitive_guide "go to top of document")[§](#Using_IO::Handle "direct link")
You can read from files using the [`IO::Handle`](/type/IO/Handle) type; this gives you a finer control over the process.
```raku
given 'some-file.txt'.IO.open {
say .readchars: 8; # OUTPUT: «I ♥ Raku»
.seek: 1, SeekFromCurrent;
say .readchars: 15; # OUTPUT: «I ♥ Programming»
.close
}
```
The [`IO::Handle`](/type/IO/Handle) gives you [.read](/type/IO/Handle#method_read), [.readchars](/type/IO/Handle#method_readchars), [.get](/type/IO/Handle#routine_get), [.getc](/type/IO/Handle#routine_getc), [.words](/type/IO/Handle#routine_words), [.lines](/type/IO/Handle#routine_lines), [.slurp](/type/IO/Handle#method_slurp), [.comb](/type/IO/Handle#method_comb), [.split](/type/IO/Handle#method_split), and [.Supply](/type/IO/Handle#method_Supply) methods to read data from it. Plenty of options; and the catch is you need to close the handle when you're done with it.
Unlike some languages, the handle won't get automatically closed when the scope it's defined in is left. Instead, it'll remain open until it's garbage collected. To make the closing business easier, some of the methods let you specify a `:close` argument, you can also use the [`will leave` trait](/language/phasers#index-entry-will_trait), or the `does auto-close` trait provided by the [`Trait::IO`](https://raku.land/zef:raku-community-modules/Trait::IO) module.
# [The wrong way to do things](#Input/Output_the_definitive_guide "go to top of document")[§](#The_wrong_way_to_do_things "direct link")
This section describes how NOT to do Raku IO.
## [Leave $\*SPEC alone](#Input/Output_the_definitive_guide "go to top of document")[§](#Leave_$*SPEC_alone "direct link")
You may have heard of [`$*SPEC`](/language/variables#Dynamic_variables) and seen some code or books show its usage for splitting and joining path fragments. Some of the routine names it provides may even look familiar to what you've used in other languages.
However, unless you're writing your own IO framework, you almost never need to use [`$*SPEC`](/language/variables#Dynamic_variables) directly. [`$*SPEC`](/language/variables#Dynamic_variables) provides low-level stuff and its use will not only make your code tough to read, you'll likely introduce security issues (e.g. null characters)!
The [`IO::Path`](/type/IO/Path) type is the workhorse of Raku world. It caters to all the path manipulation needs as well as provides shortcut routines that let you avoid dealing with filehandles. Use that instead of the [`$*SPEC`](/language/variables#Dynamic_variables) stuff.
Tip: you can join path parts with `/` and feed them to [`IO::Path`](/type/IO/Path)'s routines; they'll still do The Right Thing™ with them, regardless of the operating system.
```raku
# WRONG!! TOO MUCH WORK!
my $fh = open $*SPEC.catpath: '', 'foo/bar', $file;
my $data = $fh.slurp;
$fh.close;
```
```raku
# RIGHT! Use IO::Path to do all the dirty work
my $data = 'foo/bar'.IO.add($file).slurp;
```
However, it's fine to use it for things not otherwise provided by [`IO::Path`](/type/IO/Path). For example, the [`.devnull` method](/routine/devnull):
```raku
{
temp $*OUT = open :w, $*SPEC.devnull;
say "In space no one can hear you scream!";
}
say "Hello";
```
## [Stringifying IO::Path](#Input/Output_the_definitive_guide "go to top of document")[§](#Stringifying_IO::Path "direct link")
Don't use the `.Str` method to stringify [`IO::Path`](/type/IO/Path) objects, unless you just want to display them somewhere for information purposes or something. The `.Str` method returns whatever basic path string the [`IO::Path`](/type/IO/Path) was instantiated with. It doesn't consider the value of the [`$.CWD` attribute](/type/IO/Path#attribute_CWD). For example, this code is broken:
```raku
my $path = 'foo'.IO;
chdir 'bar';
# WRONG!! .Str DOES NOT USE $.CWD!
run <tar -cvvf archive.tar>, $path.Str;
```
The [`chdir`](/routine/chdir) call changed the value of the current directory, but the `$path` we created is relative to the directory before that change.
However, the [`IO::Path`](/type/IO/Path) object *does* know what directory it's relative to. We just need to use [`.absolute`](/routine/absolute) or [`.relative`](/routine/relative) to stringify the object. Both routines return a [`Str`](/type/Str) object; they only differ in whether the result is an absolute or relative path. So, we can fix our code like this:
```raku
my $path = 'foo'.IO;
chdir 'bar';
# RIGHT!! .absolute does consider the value of $.CWD!
run <tar -cvvf archive.tar>, $path.absolute;
# Also good:
run <tar -cvvf archive.tar>, $path.relative;
```
## [Be mindful of $\*CWD](#Input/Output_the_definitive_guide "go to top of document")[§](#Be_mindful_of_$*CWD "direct link")
While usually out of view, every [`IO::Path`](/type/IO/Path) object, by default, uses the current value of [`$*CWD`](/language/variables#Dynamic_variables) to set its [`$.CWD` attribute](/type/IO/Path#attribute_CWD). This means there are two things to pay attention to.
### [temp the $\*CWD](#Input/Output_the_definitive_guide "go to top of document")[§](#temp_the_$*CWD "direct link")
This code is a mistake:
```raku
# WRONG!!
my $*CWD = "foo".IO;
```
The `my $*CWD` made [`$*CWD`](/language/variables#Dynamic_variables) undefined. The [`.IO`](/routine/IO) coercer then goes ahead and sets the [`$.CWD` attribute](/type/IO/Path#attribute_CWD) of the path it's creating to the stringified version of the undefined `$*CWD`; an empty string.
The correct way to perform this operation is use [`temp`](/routine/temp) instead of `my`. It'll localize the effect of changes to [`$*CWD`](/language/variables#Dynamic_variables), just like `my` would, but it won't make it undefined, so the [`.IO`](/routine/IO) coercer will still get the correct old value:
```raku
temp $*CWD = "foo".IO;
```
Better yet, if you want to perform some code in a localized [`$*CWD`](/language/variables#Dynamic_variables), use the [`indir` routine](/routine/indir) for that purpose.
|
## dist_zef-tbrowder-Text-Utils.md
[](https://github.com/tbrowder/Text-Utils/actions) [](https://github.com/tbrowder/Text-Utils/actions) [](https://github.com/tbrowder/Text-Utils/actions)
# NAME
Text::Utils - Miscellaneous text utilities
# SYNOPSIS
```
# Export individual routines or :ALL
use Text::Utils :strip-comment;
my $text = q:to/HERE/;
any kind of text, including code"; # some comment
my $s = 'foo'; # another comment
HERE
for $text.lines -> $line is copy {
$line = strip-comment $line;
say $line;
}
# OUTPUT with comments removed:
any kind of text, including code;
my $s = 'foo';
```
# DESCRIPTION
The module contains several routines to make text handling easier for module and program authors. The routines:
| Name | Notes |
| --- | --- |
| commify | |
| count-substrs | |
| list2text | |
| normalize-string | alias 'normalize-text' |
| sort-list | |
| split-line | aliases 'splitstr', 'split-str' |
| strip-comment | |
| wrap-paragraph | 'width' is in PS points |
| wrap-text | 'width' is in number of chars |
Following is a short synopsis and signature for each of the routines.
### commify
This routine was originally ported from the Perl version in the *The Perl Cookbook, 2e*.
The routine adds commas to a number to separate multiples of a thousand. For example, given an input of `1234.56`, the routine returns `1,234.56`.
As an improvement, if real numbers are input, the routine returns the number stringified with two decimal places. The user may specify the desired number with the new `:$decimals` named argument.
The signature:
```
sub commify($num, :$decimals --> Str) is export(:commify)
{...}
```
### count-substrs
Count instances of a substring in a string.
The signature:
```
sub count-substrs(
Str:D $string,
Str:D $substr
--> UInt
) is export(:count-substrs)
{...}
```
### list2text
Turn a list into a text string for use in a document.
For example, this list `1 2 3` becomes either this `"1, 2, and 3"` (the default result) or this `"1, 2 and 3"` (if the `$optional-comma` named variable is set to false). The default result uses the so-called *Oxford Comma* which is not popular among some writers, but those authors may change the default behavior by permanently by defining the environment variable `TEXT_UTILS_NO_OPTIONAL_COMMA`.
The signature:
```
sub list2text(
@list,
:$optional-comma is copy = True
) is export(:list2text)
{...}
```
### normalize-text
Alias for 'normalize-string'.
### normalize-string
This routine trims a string and collapses multiple whitespace characters (including tabs and newlines) into one.
The signature:
```
subset Kn of Any where { $_ ~~ /^ :i [0|k|n] /}; #= keep or normalize
subset Sn of Any where { $_ ~~ /^ :i [0|n|s|t] /}; #= collapse all contiguous ws
sub normalize-string(
Str:D $str is copy
Kn :t(:$tabs)=0, #= keep or normalize
Kn :n(:$newlines)=0, #= keep or normalize
Sn :c(:$collapse-ws-to)=0, #= collapse all contiguous ws
#= to one char
--> Str) is export(:normalize-string)
{...}
```
'Normalization' is the process of converting a contiguous sequence of space characters into a single character. The three space characters recognized are " " (0x20, 'space'), "\t" (0x09, tab), and "\n" (0x0A, 'newline'). The default algorithm to do that for a string `$s` is `$s = s:g/ \s ** 2 / /`.
This routine gives several options to control how the target string is 'normalized'. First, the user may choose one or more of the space character types to be normalized individually. Second, the user may choose to 'collapse' all space characters to one of the three types.
Given a string with spaces, tabs, and newlines:
```
my $s = " 1 \t\t\n\n 2 \n\t 3 ";
```
The default:
```
say normalize-string($s) # OUTPUT: «1 2 3»
```
Normalize each tab:
```
say normalize-string($s, :t<n>) # OUTPUT: «1 \t\n\n 2 \n\t 3»
```
Normalize each newline:
```
say normalize-string($s, :n<n>) # OUTPUT: «1 \t\t\n 2 \n\t 3»
```
Normalize each tab and newline:
```
say normalize-string($s, :t<n>, :n<n>) # OUTPUT: «1 \t\n 2 \n\t 3»
```
Collapse to a space:
```
say normalize-string($s, :c<s>) # OUTPUT: «1 2 3»
```
Collapse to a tab:
```
say normalize-string($s, :c<t>) # OUTPUT: «1\t2\t3»
```
Collapse to a newline:
```
say normalize-string($s, :c<n>) # OUTPUT: «1\n2\n3»
```
Notice that in the normalization routines, spaces (' ') are always normalized, even when tabs and newlines are normalized separately.
Also notice all strings are normally trimmed of leading and trailing whitespace regardless of the option used. However, option `:no-trim` protects the input string from any such trimming. Consider the first example from above:
```
my $s = " 1 \t\t\n\n 2 \n\t 3 ";
```
Using the 'no-trim' option:
```
say normalize-string($s, :no-trim) # OUTPUT: « 1 2 3 »
```
### sort-list
```
# StrLength, LengthStr, Str, Length, Number
enum Sort-type is export(:sort-list) < SL LS SS LL N >;
sub sort-list(@list, :$type = SL, :$reverse --> List) is export(:sort-list)
{...}
```
By default, this routine sorts all lists by word length, then by Str order. The order by length is by the shortest abbreviation first unless the `:$reverse` option is used.
The routine's output can be modified for other uses by entering the `:$type` parameter to choose another of the `enum Sort-type`s.
### split-line
Splits a string into two pieces.
Inputs are the string to be split, the split character or string, maximum length, a starting position for the search, and the search direction (normally forward unless the `:$rindex` option is `True`).
An additional option, `:$break-after`, causes the split to be delayed to the position after the input break string on a normal forward split.
It returns the two parts of the split string. The second part will be shortened to the `:$max-line-length` value if its entered value is greater than the default zero.
The signature:
```
sub split-line(
Str:D $line is copy,
Str:D $brk,
UInt :$max-line-length = 0,
UInt :$start-pos = 0,
Bool :$rindex = False,
Bool :$break-after = False,
--> List) is export(:split-line)
{...}
```
### strip-comment
Strip the comment from an input text line, save comment if requested, normalize returned text if requested.
The routine returns a string of text with any comment stripped off. Note the designated character will trigger the strip even though it is escaped or included in quotes. Also returns the comment, including the comment character, if requested. All returned text is normalized if requested. Any returned comment will also be normalized if the `normalize-all` option is used in place of `normalize`.
The signature:
```
sub strip-comment(
$line is copy, # string of text with possible comment
:mark(:$comment-char) = '#', # desired comment character indicator
# (with alias :$comment-char)
:$save-comment, # if true, return the comment
:$normalize, # if true, normalize returned string
:$normalize-all, # if true, normalize returned string
# and also normalize any saved comment
:$last, # if true, use the last instead of first
# comment character
:$first, #= if true, the comment char must be the
#= first non-whitespace character on
#= the line; otherwise, the line is
#= returned as is
) is export(:strip-comment)
{...}
```
Note the default return is the returned string without any comment. However, if you use the `save-comment` option, a two-element list is returned: `($string, $comment)` (either element may be "" depending upon the input text line).
### wrap-paragraph
This routine wraps a list of words into a paragraph with a maximum line width in characters (default: 78), and returns a list of the new paragraph's lines formatted as desired. An option, `:$para-pre-text`, used in conjunction with `:$para-indent`, is very useful for use in auto-generation of code. For example, given this chunk of text describing a following PDF method `MoveTo(x, y)`:
```
my $str = q:to/HERE/;
Begin a new sub-path by moving the current point to coordinates (x,
y), omitting any connecting line segment. If the previous path
construction operator in the current path was also m, the new m
overrides it.
HERE
```
Run that string through the sub to see the results:
```
my @para = wrap-paragraph $str.lines, :para-pre-text('#| '), :para-indent(4);
.say for @para;
```
yields:
```
#| Begin a new sub-path by moving the current point to coordinates (x, y),
#| omitting any connecting line segment. If the previous path construction
#| operator in the current path was also m, the new m overrides it.
```
The signature:
```
multi sub wrap-paragraph(
@text,
UInt :$max-line-length = 78,
#------------------------------#
UInt :$para-indent = 0,
UInt :$first-line-indent = 0,
UInt :$line-indent = 0,
#------------------------------#
Str :$para-pre-text = '',
Str :$first-line-pre-text = '',
Str :$line-pre-text = '',
#------------------------------#
:$debug,
--> List) is export(:wrap-paragraph)
{...}
multi sub wrap-paragraph(
$text,
# ... other args same as the other multi
--> List) is export(:wrap-paragraph)
{...}
```
### wrap-text
This routine is used in creating PostScript PDF or other output formats where blocks (e.g., paragraphs) need to be wrapped to a specific maximum width based on the font face and font size to be used. Note it has all the options of the **wrap-paragraph** routine except the `:width` is expressed in PostScript points (72 per inch) as is the `:font-size`. The default `:width` is 468 points, the length of a line on a Letter paper, portrait orientation, with one-inch margins on all sides.
The fonts currently handled are the the 14 PostScript and PDF *Core Fonts*:
| |
| --- |
| Courier |
| Courier-Bold |
| Courier-Oblique |
| Courier-BoldOblique |
| Helvetica |
| Helvatica-Bold |
| Helvetica-Oblique |
| Helvatica-BoldOblique |
| Times-Roman |
| Times-Bold |
| Times-Italic |
| Times-BoldItalic |
| Symbol |
| Zaphdingbats |
```
multi sub wrap-text(
@text,
Real :$width = 468, #= PS points for 6.5 inches
:$font-name = 'Times-Roman',
Real :$font-size = 12,
#------------------------------#
UInt :$para-indent = 0,
UInt :$first-line-indent = 0,
UInt :$line-indent = 0,
#------------------------------#
Str :$para-pre-text = '',
Str :$first-line-pre-text = '',
Str :$line-pre-text = '',
#------------------------------#
:$debug,
--> List) is export(:wrap-text)
{...}
multi sub wrap-text(
$text,
# ... other args same as the other multi
--> List) is export(:wrap-text)
{...}
```
# AUTHOR
Tom Browder [tbrowder@cpan.org](mailto:tbrowder@cpan.org)
# COPYRIGHT AND LICENSE
Copyright © 2019-2024 Tom Browder
This library is free software; you may redistribute it or modify it under the Artistic License 2.0.
|
## dist_cpan-RBT-Text-Diff.md
# NAME
Text::Diff - Perform diffs on files and record sets
# SYNOPSIS
```
use Text::Diff;
# Mix and match filenames, strings, file handles, producer subs,
# or arrays of records; returns diff in a string.
# WARNING: can return B<large> diffs for large files.
my $diff = diff $string1, $string2, output-style => Context;
my $diff = diff '/tmp/log1.txt'.IO.open, '/tmp/log2.txt'.IO.open;
my $diff = diff @records1, @records2;
# May also mix input types:
my $diff = diff @records1, $string2;
```
# DESCRIPTION
`diff()` provides a basic set of services akin to the GNU "diff"
utility. It is not anywhere near as feature complete as GNU "diff", but
it is better integrated with Perl and available on all platforms. It is
often faster than shelling out to a system's "diff" executable for small
files, and generally slower on larger files.
Relies on Algorithm::Diff for, well, the algorithm. This may not produce
the same exact diff as a system's local "diff" executable, but it will
be a valid diff and comprehensible by "patch".
```
diff($a, $b, Int :offset-a = 0, Int :offset-b = 0, Str :filename-a = 'A', Str :filename-b = 'B',
Instant :mtime-a, Instant :mtime-b, OutputStyle :output-style = Unified,
Int :context-lines = 3 --> Str)
```
# OPTIONS
`diff()` takes two parameters from which to draw input and a set of
options to control it's output. The options are:
## context-lines
How many lines before and after each diff to display. Defaults to 3.
## filename-a, filename-b, mtime-a, mtime-b
The name of the file and the modification time "files"
These are filled in automatically for each file when diff() is
passed a filename, unless a defined value is passed in.
If a filename is not passed in and filename-a and filename-b are not
provided then "A" and "B" will be used as defaults.
## offset-a, offset-b
The index of the first line / element. These default to 1 for all
parameter types except ARRAY references, for which the default is 0.
This is because ARRAY references are presumed to be data structures,
while the others are line oriented text.
## output-style
`Unified`, `Context`, and `Table`.
Defaults to "Unified" (unlike standard "diff", but Unified is what's
most often used in submitting patches and is the most human readable
of the three.
`Table` presents a left-side/right-side comparison of the file contents.
This will not worth with patch but it is very human readable for thin
files.
```
+--+----------------------------------+--+------------------------------+
| |../Test-Differences-0.2/MANIFEST | |../Test-Differences/MANIFEST |
| |Thu Dec 13 15:38:49 2001 | |Sat Dec 15 02:09:44 2001 |
+--+----------------------------------+--+------------------------------+
| | * 1|Changes *
| 1|Differences.pm | 2|Differences.pm |
| 2|MANIFEST | 3|MANIFEST |
| | * 4|MANIFEST.SKIP *
| 3|Makefile.PL | 5|Makefile.PL |
| | * 6|t/00escape.t *
| 4|t/00flatten.t | 7|t/00flatten.t |
| 5|t/01text_vs_data.t | 8|t/01text_vs_data.t |
| 6|t/10test.t | 9|t/10test.t |
+--+----------------------------------+--+------------------------------+
```
This format also goes to some pains to highlight "invisible" characters
on differing elements by selectively escaping whitespace:
```
+--+--------------------------+--------------------------+
| |demo_ws_A.txt |demo_ws_B.txt |
| |Fri Dec 21 08:36:32 2001 |Fri Dec 21 08:36:50 2001 |
+--+--------------------------+--------------------------+
| 1|identical |identical |
* 2| spaced in | also spaced in *
* 3|embedded space |embedded tab *
| 4|identical |identical |
* 5| spaced in |\ttabbed in *
* 6|trailing spaces\s\s\n |trailing tabs\t\t\n *
| 7|identical |identical |
* 8|lf line\n |crlf line\r\n *
* 9|embedded ws |embedded\tws *
+--+--------------------------+--------------------------+
```
## LIMITATIONS
Since the module relies on Raku's internal line splitting which processes files as expected but
hides the details. Features such as notification about new-line at end-of-file, or differences
between \n and \r\n lines are not reported.
This module also does not (yet) provide advanced GNU diff features such as ignoring blank lines
or whitespace.
## AUTHOR
Adam Kennedy [adamk@cpan.org](mailto:adamk@cpan.org)
Barrie Slaymaker [barries@slaysys.com](mailto:barries@slaysys.com)
Ported from CPAN5 By: Rod Taylor [rbt@cpan.org](mailto:rbt@cpan.org)
## LICENSE
You can use and distribute this module under the terms of the The Artistic License 2.0. See the LICENSE file included in this distribution for complete details.
|
## dist_zef-grizzlysmit-App-pack.raku.md
# App::pack
# Module Pack
## Table of Contents
* [NAME](#name)
* [AUTHOR](#author)
* [VERSION](#version)
* [TITLE](#title)
* [SUBTITLE](#subtitle)
* [COPYRIGHT](#copyright)
* [Introduction](#introduction)
* [Motivation](#motivation)
* [Fix](#fix)
# NAME
App::pack
# AUTHOR
Francis Grizzly Smit ([grizzly@smit.id.au](mailto:grizzly@smit.id.au))
# VERSION
v0.1.0
# TITLE
pack
# SUBTITLE
A Raku program to manage the use of **gnome-extensions pack**, it has too many arguments this makes it easy.
# COPYRIGHT
GPL V3.0+ [LICENSE](https://github.com/grizzlysmit/Usage-Utils/blob/main/LICENSE)
[Top of Document](#table-of-contents)
# Introduction
This is a Raku program to manage the use of **gnome-extensions pack**, it has too many arguments this makes it easy.
## Motivation
The command **gnome-extensions pack** has too many arguments this takes care of that making it easier to package up your gnome-shell extensions.
### pack
```
pack.raku --help
Usage:
pack.raku do <dir> [-f|--force]
pack.raku create <package-dir> [<extra-sources> ...] [-s|--schema=<Str>] [-p|--podir=<Str>] [-g|--gettext-domain=<Str>] [-o|--out-dir=<Str>] [-f|--force]
pack.raku add <package-dir> [<extra-sources> ...] [-s|--schema=<Str>] [-p|--podir=<Str>] [-g|--gettext-domain=<Str>] [-o|--out-dir=<Str>] [-f|--force] [-F|--stomp-force] [-S|--stomp]
pack.raku set schema <package-dir> <schema-value>
pack.raku set podir <package-dir> <podir-value>
pack.raku set gettext-domain <package-dir> <gettext-domain-value>
pack.raku set out-dir <package-dir> <out-dir-value>
pack.raku set force <package-dir> <force-value>
pack.raku add-extra-sources <package-dir> [<extra-sources> ...]
pack.raku set package-dir <package-dir> <package-dir-value>
pack.raku set extra-sources <package-dir> [<extra-sources> ...]
pack.raku append extra-sources <package-dir> [<extra-sources> ...]
pack.raku remove schema <package-dir>
pack.raku remove podir <package-dir>
pack.raku remove gettext-domain <package-dir>
pack.raku remove out-dir <package-dir>
pack.raku remove extra-sources <package-dir>
pack.raku get schema <package-dir>
pack.raku get podir <package-dir>
pack.raku get gettext-domain <package-dir>
pack.raku get out-dir <package-dir>
pack.raku get extra-sources <package-dir>
pack.raku get force <package-dir>
pack.raku get package-dir <package-dir>
pack.raku alias add <key> <target> [-s|--set|--force] [-c|--comment=<Str>]
pack.raku alias do <key> [-f|--force]
pack.raku edit configs
pack.raku list keys [<prefix>] [-c|--color|--colour] [-s|--syntax] [-l|--page-length[=Int]] [-p|--pattern=<Str>] [-e|--ecma-pattern=<Str>]
pack.raku list all [<prefix>] [-c|--color|--colour] [-s|--syntax] [-l|--page-length[=Int]] [-p|--pattern=<Str>] [-e|--ecma-pattern=<Str>]
pack.raku delete [<keys> ...] [-d|--delete|--do-not-trash
pack.raku del [<keys> ...] [-d|--delete|--do-not-trash]
pack.raku trash [<keys> ...]
pack.raku tidy file
pack.raku comment <key> <comment> [-k|--kind=<Str where \{ ... } >]
pack.raku list trash [<prefix>] [-c|--color|--colour] [-s|--syntax] [-l|--page-length[=Int]] [-p|--pattern=<Str>] [-e|--ecma-pattern=<Str>]
pack.raku empty trash
pack.raku undelete [<keys> ...]
pack.raku show stats [<prefix>] [-c|--color|--colour] [-s|--syntax] [-p|--pattern=<Str>] [-e|--ecma-pattern=<Str>]
pack.raku show statistics [<prefix>] [-c|--color|--colour] [-s|--syntax] [-p|--pattern=<Str>] [-e|--ecma-pattern=<Str>]
pack.raku backup db [-w|--win-format|--use-windows-formating]
pack.raku restore db [<restore-from>]
pack.raku menu restore db [<message>] [-c|--color|--colour] [-s|--syntax]
pack.raku list db backups [<prefix>] [-c|--color|--colour] [-s|--syntax] [-l|--page-length[=Int]] [-p|--pattern=<Str>] [-e|--ecma-pattern=<Str>]
pack.raku list editors [-f|--prefix=<Str>] [-c|--color|--colour] [-s|--syntax] [-l|--page-length[=Int]] [-p|--pattern=<Str>] [-e|--ecma-pattern=<Str>]
pack.raku editors stats [<prefix>] [-c|--color|--colour] [-s|--syntax] [-l|--page-length[=Int]] [-p|--pattern=<Str>] [-e|--ecma-pattern=<Str>]
pack.raku list editors backups [<prefix>] [-c|--color|--colour] [-s|--syntax] [-l|--page-length[=Int]] [-p|--pattern=<Str>] [-e|--ecma-pattern=<Str>]
pack.raku backup editors [-w|--use-windows-formatting]
pack.raku restore editors <restore-from>
pack.raku set editor <editor> [<comment>]
pack.raku set override GUI_EDITOR <value> [<comment>]
pack.raku menu restore editors [<message>] [-c|--color|--colour] [-s|--syntax]
```
```
pack.raku do --help
Usage:
pack.raku do <dir> [-f|--force]
```
|
## dist_zef-thundergnat-Filetype-Magic.md
[](https://github.com/thundergnat/Filetype-Magic/actions)
# NAME Filetype::Magic
Try to guess a files type using the libmagic heuristic library.
# SYNOPSIS
Object oriented mode:
```
use Filetype::Magic;
my $magic = Magic.new;
say $magic.type: '/path/to/file.name';
```
Or use a convenience function.
Subroutine interface:
```
use Filetype::Magic;
say file-type '/path/to/file.name';
```
# DESCRIPTION
Provides a Raku interface to the libmagic shared library used by the 'file' utility to guess file types, installed by default on most BSDs and Linuxs. Libraries available for OSX and Windows as well.
Linux / BSD / OSX: Needs to have the shared library: libmagic-dev installed. May install the shared library directly or install the file-dev packages which will include the shared libmagic library file. Needs the header files so will need the dev packages even if you already have libmagic installed.
Windows: Needs libmagic.dll. Older 32bit packages are available on the authors site; the newest version available is 5.03. 64bit dlls can be built by following instructions on the nscaife github page (link below). At 5.29 by default, though it appears that it attempts to update to the latest version on build. (5.32 as of this writing.)
| Platform | Install Method |
| --- | --- |
| Debian derivatives | [sudo] apt-get install libmagic-dev |
| FreeBSD | [sudo] pkg install libmagic-dev |
| Fedora | [sudo] dnf install libmagic-dev |
| OSX | [sudo] brew install libmagic |
| OpenSUSE | [sudo] zypper install libmagic-dev |
| Red Hat | [sudo] yum install file-devel |
| Source Code on GitHub | https://github.com/file/file |
| Windows 32bit (older) | http://gnuwin32.sourceforge.net/packages/file.htm |
| Windows 64bit (newer) | https://github.com/nscaife/file-windows |
---
## FLAGS
There is a series of flags which control the behavior of the search:
| Flag | hex value | meaning |
| --- | --- | --- |
| MAGIC\_NONE | 0x000000, | No flags |
| MAGIC\_DEBUG | 0x000001, | Turn on debugging |
| MAGIC\_SYMLINK | 0x000002, | Follow symlinks |
| MAGIC\_COMPRESS | 0x000004, | Check inside compressed files |
| MAGIC\_DEVICES | 0x000008, | Look at the contents of devices |
| MAGIC\_MIME\_TYPE | 0x000010, | Return the MIME type |
| MAGIC\_CONTINUE | 0x000020, | Return all matches |
| MAGIC\_CHECK | 0x000040, | Print warnings to stderr |
| MAGIC\_PRESERVE\_ATIME | 0x000080, | Restore access time on exit |
| MAGIC\_RAW | 0x000100, | Don't translate unprintable chars |
| MAGIC\_ERROR | 0x000200, | Handle ENOENT etc as real errors |
| MAGIC\_MIME\_ENCODING | 0x000400, | Return the MIME encoding |
| MAGIC\_MIME | 0x000410, | MAGIC\_MIME\_TYPE +| MAGIC\_MIME\_ENCODING |
| MAGIC\_APPLE | 0x000800, | Return the Apple creator and type |
| MAGIC\_NO\_CHECK\_COMPRESS | 0x001000, | Don't check for compressed files |
| MAGIC\_NO\_CHECK\_TAR | 0x002000, | Don't check for tar files |
| MAGIC\_NO\_CHECK\_SOFT | 0x004000, | Don't check magic entries |
| MAGIC\_NO\_CHECK\_APPTYPE | 0x008000, | Don't check application |
| MAGIC\_NO\_CHECK\_ELF | 0x010000, | Don't check for elf details |
| MAGIC\_NO\_CHECK\_TEXT | 0x020000, | Don't check for text files |
| MAGIC\_NO\_CHECK\_CDF | 0x040000, | Don't check for cdf files |
| MAGIC\_NO\_CHECK\_TOKENS | 0x100000, | Don't check tokens |
| MAGIC\_NO\_CHECK\_ENCODING | 0x200000, | Don't check text encodings |
The flags may be set during construction by passing a :flags(WHATEVER) value in to the `.new( )` method, or may be adjusted later using the `.set-flags( )` method.
## FUNCTIONS - subroutine interface
Useful for one-and-done, one-off use.
```
sub file-type( IO::Path $path, Bool :$mime )
# or
sub file-type( Str $filename, Bool :$mime )
# or
sub file-type( IO::Handle $handle, Bool :$mime )
# or
sub file-type( Buf $buffer, Bool :$mime )
```
Try to detect file type of a given file path/name, or open file handle, or string buffer. Strings must be in a specific encoding for the C library, so to avoid encoding issues and to differentiate string buffers from string filenames, you must pass strings as a Buf encoded appropriately. Pass a keyword parameter `mime` to get a mime type result.
--
## METHODS - object interface
For when you would like a persistent instance.
```
method new # Default database, default flags(none)
# or
method new( :magicfile( '/path/to/magic/database.file' ) ) # Load a custom database
# or
method new( :flags( MAGIC_SYMLINK +| MAGIC_MIME ) ) # Adjust search/reporting behavior
```
Construct a new `Magic` instance with passed parameters if desired.
--
```
method set-flags( int32 $flags = 0 )
```
Allows modification of parameters after initialization. Numeric-bitwise `or` any parameters together.
E.G. `$magic-instance.set-flags( MAGIC_SYMLINK +| MAGIC_MIME )`.
--
```
method get-flags( )
```
Query which flags are set, returns the int32 value of the set flags.
--
```
method type( IO::Path $path )
# or
method type( Str $filename )
# or
method type( IO::Handle $handle )
# or
method type( Buf $buffer )
```
Try to detect file type of a given a file path/name, or open file handle, or string buffer. Strings must be in a specific encoding for the C library, so to avoid encoding issues and to differentiate string buffers from string filenames, you must pass strings as a Buf encoded appropriately.
--
```
method version()
```
Return the current version. First digit is major version number, rest are minor.
---
There are several semi-private methods which mostly deal with initialization and setup. There is nothing preventing you from accessing them, they are publically available, but most people won't ever need to use them.
```
method magic-database( str $magic-database, int32 $flags )
```
Location of the magic database file, pass Nil to load the default database. Pass any flags numeric-bitwise `or`ed together to adjust behavior. (See `method set-flags`)
--
```
method magic-init( int32 $flags = 0 )
```
Initialize the file-magic instance, allocate a data structure to hold information and return a pointer to it. Pointer is stored in the class as $!magic-cookie.
--
```
method magic-load( Pointer $magic-struct, str $database-list )
```
Load the database file(s) into the data structure.
--
```
method magic-error()
```
Pass any errors back up to the calling code.
--
Once the Magic instance is initialized, you may query the database locations by checking the `$magic-instance.database` string. Contains the various file paths to loaded database files as a colon separated string. Do not try to change the database string directly. It will not affect the current instance; it is only a convenience method to make it easier to see the currently loaded files. Changes to the database need to be done with the `magic-load( )` method.
---
A few methods dealing with generating, compiling, and checking magic database files have yet to be implemented.
# AUTHOR
2019 Steve Schulze aka thundergnat
This package is free software and is provided "as is" without express or implied warranty. You can redistribute it and/or modify it under the same terms as Perl itself.
libmagic library and file utility v5.x author: Ian Darwin, Christos Zoulas, et al.
#### CONTRIBUTORS
github: gmoshkin
# LICENSE
Licensed under The Artistic 2.0; see LICENSE.
|
## unpack.md
unpack
Combined from primary sources listed below.
# [In role Blob](#___top "go to top of document")[§](#(role_Blob)_routine_unpack "direct link")
See primary documentation
[in context](/type/Blob#routine_unpack)
for **routine unpack**.
This method is considered **experimental**, in order to use it you will need to do:
```raku
use experimental :pack;
multi method unpack(Blob:D: Str:D $template)
multi method unpack(Blob:D: @template)
multi unpack(Blob:D \blob, Str:D $template)
multi unpack(Blob:D \blob, @template)
```
Extracts features from the blob according to the template string, and returns them as a list.
The template string consists of zero or more units that begin with an ASCII letter, and are optionally followed by a quantifier. The quantifier can be `*` (which typically stands for "use up the rest of the Blob here"), or a positive integer (without a `+`).
Whitespace between template units is ignored.
Examples of valid templates include `"A4 C n*"` and `"A*"`.
The following letters are recognized:
| Letter | Meaning |
| --- | --- |
| A | Extract a string, where each element of the Blob maps to a codepoint |
| a | Same as 'A' |
| C | Extract an element from the blob as an integer |
| H | Extracts a hex string |
| L | Extracts four elements and returns them as a single unsigned integer |
| n | Extracts two elements and combines them in "network" (BigEndian) byte order into a single integer |
| N | Extracts four elements and combines them in "network" (BigEndian) byte order into a single integer |
| S | Extracts two elements and returns them as a single unsigned integer |
| v | Same as 'S' |
| V | Same as 'L' |
| x | Drop an element from the blob (that is, ignore it) |
| Z | Same as 'A' |
Example:
```raku
use experimental :pack;
say Blob.new(1..10).unpack("C*");
# OUTPUT: «(1 2 3 4 5 6 7 8 9 10)»
```
|
## dist_cpan-TYIL-File-Zip.md
# NAME
File::Zip
# AUTHOR
Patrick Spek [p.spek@tyil.work](mailto:p.spek@tyil.work)
# VERSION
0.1.2
# Description
A wrapper around zip files, using zip/unzip commands
# Installation
Install this module through [zef](https://github.com/ugexe/zef):
```
zef install File::Zip
```
# License
This module is distributed under the terms of the AGPL-3.0.
|
## dist_cpan-WBIKER-Module2Rpm.md
# NAME
App::Module2Rpm
# SYNOPSIS
```
# Download the source of a Raku module, write the spec file and upload them to OBS.
module2rpm --module=Module::Name
# Download the source, write the spec file and upload them to OBS for each line in a file.
module2rm --file=filePath
```
# DESCRIPTION
This program downloads the source of a given Raku module, writes the spec file with the module
metadata and uploaded them to Open Build Service (OBS).
There are two commandline parameter:
* `--module=Module::Name` Looks for the metadata of the given name to find the
source download url and metadata.
* `--file=FilePath` Handles each line in the file as either module name or metadata
download url.
# AUTHOR
wbiker [wbiker@gmx.at](mailto:wbiker@gmx.at)
|
## dist_github-MadcapJake-Acme-Mangle.md
```
mangle "Hello from the other side. I must've called a thousand times."
```
### Thanks
[yoleaux](http://dpk.io/yoleaux)'s `.mangle` command
Jean-Yves Lefort's [libtranslate](http://www.nongnu.org/libtranslate/)
|
## dist_zef-jonathanstowe-Ikoko.md
# Ikoko
Simple Read-Only interface to the AWS Secrets Manager
[](https://github.com/jonathanstowe/Ikoko/actions/workflows/main.yml)
## Synopsis
```
use Ikoko;
use Kivuli;
# Using Kivuli to get session credentials for a role in EC2
# The access-key-id and secret-access-key could come from configuration
my $k = Kivuli.new;
my $ikoko = Ikoko.new(region => 'eu-west-2', access-key-id => $k.access-key-id, secret-access-key => $k.secret-access-key, token => $k.token );
say $ikoko.get-secret-value("db-user").secret-string;
```
## Description
This provides a simple interface to the [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/index.html). The secrets manager enables an application to retrieve a secret credential (for, say, an RDS database ) at run time without having to save it in your application configuration.
If used with [Kivuli](https://docs.aws.amazon.com/secretsmanager/index.html) in an EC2 or Elasticbeanstalk instance you can avoid having all credentials in the configuration or application code. When used with the temporary credentials as supplied by Kivuli the `token` must be provided. If you are using a permanent access key for
an account then the `token` is optional.
For this to work the account or IAM role must have permission to retrieve the secrets, which is described [here](https://docs.aws.amazon.com/secretsmanager/latest/userguide/auth-and-access.html).
Currently this only implements `GetSecretValue` as this is most useful for an application.
## Installation
Assuming you have a working installation of rakudo you should be able to install this with *zef* :
```
zef install Ikoko
```
## Support
This currently only implements the bare essentials for my needs, if you need some other features or have other suggestions or patches please raise an issue on [Github](https://github.com/jonathanstowe/Ikoko/issues) and I'll see what I can do.
Although the unit tests are rather thin, rest assured that I have tested this manually and is being used in the project I wrote it for.
## Licence & Copyright.
This is free software. Please see the <LICENCE> in the distribution for details.
© Jonathan Stowe 2021
|
## dist_zef-guifa-DateTime-React.md
# DateTime::React
A module for Raku that makes it incredibly easy to be alerted when clock rollovers occur (e.g. when the minute or hour ticks up).
Using it is very simple:
```
use DateTime::React;
react {
whenever minute-shifts {
say "We've gone from ??:??:59 to ??:??:00!";
}
whenever hour-shifts {
say "We've gone from ??:59:59 to to ??:00:00!";
}
whenever day-shifts {
say "We've gone from 23:59:59 to to 00:00:00!";
}
whenever timezone-shifts -> $shift {
say "The offset in {$shift.timezone} is now {$shift.new-offset}!";
}
}
```
Other time options presently include `month-shifts` and `year-shifts` (these are pegged to the Gregorian calendar).
Each supply emits a meta event of type `DateTimeEventish`. It provides three values:
* **`time`**: the time the event was scheduled
* **`next-at`**: when the next event will occur
* **`type`**: the type of event (any of *minute, hour, day, month, year, timezone*)
Currently, only `timezone-shifts()` provides additional metadata:
* **`olson-id`**: the Olson (or IANA) identifier for the timezone
* **`timezone`**: an alias of `olson-id`
* **`old-offset`**: the former GMT offset (e.g. -5h for *America/New\_York* for spring switch over)
* **`new-offset`**: the now current GMT offset (e.g. -4h for *America/New\_York* for spring switch over)
When using `timezone-shifts()`, this module will (currently) automatically adjust the `$*TZ` value for you so that new DateTime objects are generated with the correct offset.
Be mindful that DateTime itself is not timezone aware, so creating historical/future dates will always use the current $\*TZ value.
If that is needed, you should look at the `DateTime::Timezones` module which does that for you.
The `$*TZ` adjusting feature may be moved into a different module down the road but the behavior will be maintained (at the cost of an additional dependency for this one).
# Version history
* **v0.2.0**
* Now using terms to avoid parentheses for teh pretty
* **v0.1.1**
* Switched to live supplies internally for improved reliability
* **v0.1.0**
* Initial release
# Copyright / License
Copyright © 2022 Matthew Stephen Stuckwisch. Licensed under the Artistic License 2.0
|
## dist_cpan-JNTHN-LEB128.md
# LEB128
[LEB128 or Little Endian Base 128](https://en.wikipedia.org/wiki/LEB128)
is a variable-length encoding of integers - that is, it aims to store
integers of different sizes efficiently. It is used in the DWARF debug
information format, Web Assembly, and other formats and protocols. This
Raku module provides both encoding and decoding.
## Encoding
There are both signed and unsigned encoding functions, `encode-leb128-signed`
and `encode-leb128-unsigned` respectively. Both are `multi`s with candidates
that take an `Int` and return a `Buf` with the encoded value:
```
my $buf-eu = encode-leb128-unsigned(1234);
my $buf-es = encode-leb128-signed(-1234);
```
Or to write the encoded `Int` into a `Buf` and return the number of bytes
written, which is often more efficient since it avoids the creation of a
temporary `Buf`:
```
my $buf = Buf.new;
my $offset = 0;
$offset += encode-leb128-unsigned(1234, $buf, $offset);
```
## Decoding
There are both signed and unsigned decoding functions, `decode-leb128-signed`
and `decode-leb128-unsigned` respectively. Both are `multi`s with candidates
that take a `Buf` and try to decode an `Int` from the start of it, returning
that `Int`:
```
my $value-du = decode-leb128-unsigned($entire-buffer-u);
my $value-ds = decode-leb128-signed($entire-buffer-s);
```
Or that decode the value from a specified offset in a given buffer, and use
an `rw` parameter of type `int`, which is incremented by the number of bytes
consumed.
```
my int $read;
my $value = decode-leb128-unsigned($buffer, $offset, $read);
```
To have the offset updated, it may be passed as both parameters:
```
my $value = decode-leb128-unsigned($buffer, $offset, $offset);
```
|
## dist_zef-lizmat-paths.md
[](https://github.com/lizmat/paths/actions) [](https://github.com/lizmat/paths/actions) [](https://github.com/lizmat/paths/actions)
# NAME
paths - A fast recursive file / directory finder
# SYNOPSIS
```
use paths;
.say for paths; # all files from current directory
.say for paths($dir); # all files from $dir
.say for paths(:dir(* eq '.git')); # files in ".git" directories
.say for paths(:file(*.ends-with(".json"); # all .json files
.say for paths(:recurse); # also recurse in non-accepted dirs
.say for paths(:follow-symlinks); # also recurse into symlinked dirs
.say for paths(:!file); # only produce directory paths
say is-regular-file('/etc/passwed'); # True (on Unixes)
)
```
# DESCRIPTION
By default exports two subroutines: `paths` (returning a `Seq` of absolute path strings of files (or directories) for the given directory and all its sub-directories (with the notable exception of `.` and `..`).
And `is-regular-file`, which returns a `Bool` indicating whether the given absolute path is a regular file.
# SELECTIVE IMPORTING
```
use paths <paths>; # only export sub paths
```
By default all utility functions are exported. But you can limit this to the functions you actually need by specifying the names in the `use` statement.
To prevent name collisions and/or import any subroutine with a more memorable name, one can use the "original-name:known-as" syntax. A semi-colon in a specified string indicates the name by which the subroutine is known in this distribution, followed by the name with which it will be known in the lexical context in which the `use` command is executed.
```
use path <paths:find-all-paths>; # export "path-exists" as "alive"
.say for find-all-paths;
```
# EXPORTED SUBROUTINES
## paths
The `paths` subroutine returns a `Seq` of absolute path strings of files for the given directory and all its sub-directories (with the notable exception of `.` and `..`).
### ARGUMENTS
* directory
The only positional argument is optional: it can either be a path as a string or as an `IO` object. It defaults to the current directory (also when an undefined value is specified. The (implicitely) specified directory will **always** be investigated, even if the directory name does not match the `:dir` argument.
If the specified path exists, but is not a directory, then only that path will be produced if the file-matcher accepts the path. In all other cases, an empty `Seq` will be returned.
* :dir
The named argument `:dir` accepts a matcher to be used in smart-matching with the basename of the directories being found. If accepted, will produce both files as well as other directories to recurse into.
It defaults to skipping all of the directories that start with a period (also if an undefined value is specified).
* :file
The named argument `:file` accepts a matcher to be used in smart-matching with the basename of the file being found. It defaults to `True`, meaning that all possible files will be produced (also if an undefined values is specified).
If the boolean value `False` is specified, then **only** the paths of directories will be produced.
* :recurse
Flag. The named argument `:recurse` accepts a boolean value to indicate whether subdirectories that did **not** match the `:dir` specification, should be investigated as well for other **directories** to recurse into. No files will be produced from a directory that didn't match the `:dir` argument.
By default, it will not recurse into directories.
* :follow-symlinks
The named argument `:follow-symlinks` accepts a boolean value to indicate whether subdirectories, that are actually symbolic links to a directory, should be investigated as well. By default, it will not.
## is-regular-file
```
say is-regular-file('/etc/passwed'); # True (on Unixes)
```
Returns a `Bool` indicating whether the given absolute path is a regular file.
# AUTHOR
Elizabeth Mattijsen [liz@raku.rocks](mailto:liz@raku.rocks)
Source can be located at: <https://github.com/lizmat/paths> . Comments and Pull Requests are welcome.
If you like this module, or what I’m doing more generally, committing to a [small sponsorship](https://github.com/sponsors/lizmat/) would mean a great deal to me!
# COPYRIGHT AND LICENSE
Copyright 2021, 2022, 2024 Elizabeth Mattijsen
This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.
|
## dist_cpan-LEONT-Actor.md
[](https://travis-ci.org/Leont/raku-actor)
# NAME
Actor - an actor model threading library
# SYNOPSIS
```
use v6.d;
use Actor;
my $actor = spawn {
receive-loop
-> Str $message, Actor::Handle $other {
say "Message $message";
$other.send($message);
},
-> Int :$number, Str :$message {
say "Message $message" if $number %% 7;
},
-> "stop" {
last;
};
}
$actor.send("message", self-handle);
receive
-> Str $message {
$actor.send(:42number, :$message);
$actor.send("stop");
};
await $actor;
```
# DESCRIPTION
Actor is a module that implements actor model threading for Raku.
actors are …
# INTERFACE
## module Actor
### spawn(&starter, \*@args, Bool :$monitored --> Handle:D)
This starts a new actor that calls `&starter` with `@args` as its arguments, and returns a handle to that actor. If `$monitored` is true, it will also set up a monitor from the new actor to the current one.
### receive(\*@handlers --> Nil)
This will loop through the messages in the queue, and for each message will try to match it in turn to each of the `@handlers` passed to it. If it matches it is taken from the queue and the handler is called with it. Then `receive` returns.
If no such matching message exists, it will wait for a new message to arrive that does match a handler, pushing any non-matching messages to the queue.
### receive-loop(\*@handlers --> Nil)
This will call receive in a loop with the given handlers, until one of the handlers calls `last`.
### self-handle(--> Handle:D)
This returns a handle to the current actor.
## class Actor::Handle
This class represents a handle to an actor
### send(|message --> Nil)
This will send `|message` to that actor.
### alive(--> Bool:D)
This returns true if the actor is still alive.
### add-monitor(handle = self-handle --> Handle::MonitorId)
This sets up a monitor relationship from the invocant handle to the one passed to `add-monitor` (defaulting to the current handle)
### remove-monitor(Handle::MonitorId $monitor)
This removes a monitor from the monitor list of this actor.
## monitors
Monitors are watchers on an actor's status. If the actor ends successfully, a message like this is sent:
```
(Actor::Exit, $handle, $return-value)
```
If it dies in an exception, the follow message is sent to the monitoring actor instead.
```
(Actor::Error, $handle, $exception)
```
# AUTHOR
Leon Timmermans [fawaka@gmail.com](mailto:fawaka@gmail.com)
# COPYRIGHT AND LICENSE
Copyright 2020 Leon Timmermans
This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.
|
## dist_cpan-RONALDWS-US-ASCII.md
# NAME
US-ASCII - ASCII restricted character classes based on Perl 6 predefined classes and ABNF/RFC5234 Core.
[](https://travis-ci.org/ronaldxs/Perl6-US-ASCII)
[](https://ci.appveyor.com/project/ronaldxs/Perl6-US-ASCII/branch/master)
# SYNOPSIS
```
use US-ASCII;
say so /<US-ASCII::alpha>/ for <A À 9>; # True, False, False
grammar IPv6 does US-ASCII-UC {
token h16 { <HEXDIG> ** 1..4}
}
# False, True, True, False, False
say so IPv6.parse($_, :rule<h16>) for ('DÉÃD', 'BEEF', 'A0', 'A๐', 'a0');
grammar SQL_92 does US-ASCII-UC {
token unsigned-integer { <DIGIT>+ }
}
# True, False
say so SQL_92.parse($_, :rule<unsigned-integer>) for ('42', '4૫');
```
```
use US-ASCII :UC;
say so /<ALPHA>/ for <A À 9>; # True, False, False
```
# DESCRIPTION
This module provides regex character classes restricted to ASCII including the predefined character classes of Perl 6 and ABNF (RFC 5234) Core rules. The US-ASCII grammar defines most character classes in lower case for direct use without composition as in the first SYNOPSIS example. The US-ASCII-UC role defines all character classes in upper case and is intended for composition into grammars. Upper case US-ASCII tokens may be imported with the import tag `:UC`. Composition of upper case named regex/tokens does not override the predefined Perl 6 character classes and conforms better to RFC 5234 ABNF, facilitating use with grammars of other internet standards based on that RFC.
The distribution also includes an `US-ASCII::ABNF::Core` module with tokens for ABNF Core as enumerated in RFC 5234. See further details in that module's documentation. There is also an `US-ASCIIx` module which is a POSIX variant with a `:POSIX` import tag and `alpha`, `alnum` and their uppercase export versions do not include underscore, '\_'.
The `US-ASCII-ABNF` role of the `US-ASCII` module extends `US-ASCII-UC` by defining all ABNF Core tokens including ones like DQUOTE that are trivially coded in Perl6 and others that are likely only to be useful for composition in grammars related to ABNF. For conformance with ABNF, `ALPHA` and `ALNUM` do not include underscore, '\_' in this module.
Unlike RFC 5234, and some existing Perl 6 implementations of it, US-ASCII rules are very rarely defined by ordinal values and mostly use, hopefully clearer, Perl 6 character ranges and names. Actually you could code most of these rules/tokens easily enough yourself as demonstrated below but the modules may still help collect and organize them for reuse.
```
my token DIGIT { <digit> & <:ascii> } # implemented with conjunction
```
# Named Regex (token)
## Named Regex (token) in differing case in US-ASCII and US-ASCII-UC/(import tag :UC)
Almost all are based on predefined Perl 6 character classes.
* alpha / ALPHA
* alpha\_x / ALPHAx # alpha without '\_' underscore
* upper / UPPER
* lower / LOWER
* digit / DIGIT
* xdigit / XDIGIT
* hexdig / HEXDIG # ABNF 0..9A..F (but not a..f)
* alnum / ALNUM
* alnum\_x / ALNUMx # alnum without '\_' underscore
* punct / PUNCT
* graph / GRAPH
* blank / BLANK
* space / SPACE
* print / PRINT
* cntrl / CNTRL
* vchar / VCHAR # ABNF \x[21]..\x[7E] visible (printing) chars
* wb / WB
* ww / WW
* ident / IDENT
## Shared by both US-ASCII and US-ASCII-UC
* BIT ('0' or '1')
* CHAR (Anything in US-ASCII other than NUL)
* CRLF
## Named Regex (token) in US-ASCII-ABNF/(import tag :ABNF) only useful for ABNF
* CR
* CTL
* DQUOTE
* HTAB
* LF
* SP (space)
* LWSP (ABNF linear white space)
* OCTET
* WSP
| ABNF Core rule | Perl 6 equivalent |
| --- | --- |
| CR | \c[CR] |
| CTL | US-ASCII cntrl / CNTRL |
| DQUOTE | '"' |
| HTAB | "\t" |
| LF | \c[LF] |
| SP | ' ' |
| WSP | US-ASCII blank / BLANK |
## US-ASCIIx import tag :POSIX
As previously mentioned for the `US-ASCII` module `ALPHA` and `ALNUM` include the underscore ('\_') and for `US-ASCIIx` those two tokens DO NOT include underscore.
* ALPHA
* UPPER
* LOWER
* DIGIT
* XDIGIT
* ALNUM
* PUNCT
* GRAPH
* BLANK
* SPACE
* PRINT
* CNTRL
# ABNF Core
Since ABNF is defined using the ASCII character set the distribution includes an US-ASCII::ABNF::Core module defining the tokens for ABNF Core as enumerated in RFC 5234. See that module's documentation for more detail.
# Backward compatibility break with CR, LF, SP.
In 0.1.X releases CR, LF and SP were provided by the US-ASCII grammar. They are now treated as ABNF Core only tokens, as they can be easily enough coded in Perl 6 using equivalents noted in the table above.
# LIMITATIONS
Perl 6 strings treat `"\c[CR]\c[LF]"` as a single grapheme and that sequence will not match either `<CR>` or `<LF>` but will match `<CRLF>`.
The Unicode `\c[KELVIN SIGN]` at code point `\x[212A]` is normalized by Perl 6 string processing to the letter 'K' and `say so "\x[212A]" ~~ /K/` prints `True`. Regex tests that match the letter K, including US-ASCII tokens, may thus appear to match the Kelvin sign.
# Export of tokens
Export of tokens and other `Regex` types is not formally documented. Regex(es) are derived from `Method` which is in turn derived from `Routine`. `Sub` is also derived from `Routine` and well documented and established as exportable including lexical `my sub`. There is a roast example of exporting an operator method in S06-operator-overloading/infix.t and also mention of method export in a Dec 12, 2009 advent blog post. Further documentation and test of export on `Method` and `Regex` types is of interest to these modules and project.
This implementation uses `my`/lexical scope to export tokens the same way a module would export a `my sub`. I looked into `our` scope and no scope specifier for the declarations and came across [roast issue #426](https://github.com/perl6/roast/issues/426), which I felt made the choice ambiguous and export of `my token` currently the best of the three.
|
## ast.md
ast
Combined from primary sources listed below.
# [In Match](#___top "go to top of document")[§](#(Match)_method_ast "direct link")
See primary documentation
[in context](/type/Match#method_ast)
for **method ast**.
Alias for [method made](#method_made).
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.