## 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
[![Actions Status](https://github.com/raku-community-modules/App-InstallerMaker-WiX/actions/workflows/windows.yml/badge.svg)](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
[![Build Status](https://travis-ci.org/ufobat/p6-StrictClass.svg?branch=master)](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

[![Build Status](https://travis-ci.org/pdf-raku/Native-Packing-raku.svg?branch=master)](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
[![Actions Status](https://github.com/pdf-raku/PDF-Font-Loader-raku/workflows/test/badge.svg)](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://img.shields.io/badge/License-Artistic%202.0-0298c3.svg)](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