@tsplc/iec 0.0.0-stage → 0.2.18

package/README.md

@@ -1,3 +1,7 @@
-# Temporary Holding Version
+# @tsplc/iec
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Part of [tsPLC](https://github.com/rip-technologies/tsplc).
+
+The IEC 61131-3 vocabulary the rest of the toolchain shares. `elementaryTypes` lists each elementary type with its family, width and signedness as CODESYS implements them, `elementaryType` finds one by its full name or its alias (`TOD`, `DT`), and `integerRange` gives the bounds of an integer or bit-string type. `sizePrefixes` gives the type each direct-address size prefix (`X`, `B`, `W`, `D`, `L`) names, and `ioScalar` and `ioArray` read the scalars and spans a process image binds. Each package selects the types it supports from here rather than keeping its own table.
+
+See the [documentation](https://github.com/rip-technologies/tsplc/tree/main/docs). MIT licensed.

package/dist/index.js

@@ -0,0 +1,100 @@
+// packages/iec/src/elementary-types.ts
+var elementaryTypes = [
+  { name: "BOOL", family: "bool", bits: 1 },
+  { name: "SINT", family: "integer", bits: 8, signed: true },
+  { name: "INT", family: "integer", bits: 16, signed: true },
+  { name: "DINT", family: "integer", bits: 32, signed: true },
+  { name: "LINT", family: "integer", bits: 64, signed: true },
+  { name: "USINT", family: "integer", bits: 8, signed: false },
+  { name: "UINT", family: "integer", bits: 16, signed: false },
+  { name: "UDINT", family: "integer", bits: 32, signed: false },
+  { name: "ULINT", family: "integer", bits: 64, signed: false },
+  { name: "BYTE", family: "bits", bits: 8, signed: false },
+  { name: "WORD", family: "bits", bits: 16, signed: false },
+  { name: "DWORD", family: "bits", bits: 32, signed: false },
+  { name: "LWORD", family: "bits", bits: 64, signed: false },
+  { name: "REAL", family: "real", bits: 32 },
+  { name: "LREAL", family: "real", bits: 64 },
+  { name: "TIME", family: "duration", bits: 32 },
+  { name: "LTIME", family: "duration", bits: 64 },
+  { name: "DATE", family: "date", bits: 32 },
+  { name: "LDATE", family: "date", bits: 64 },
+  { name: "TIME_OF_DAY", alias: "TOD", family: "timeOfDay", bits: 32 },
+  { name: "LTIME_OF_DAY", alias: "LTOD", family: "timeOfDay", bits: 64 },
+  { name: "DATE_AND_TIME", alias: "DT", family: "dateTime", bits: 32 },
+  { name: "LDATE_AND_TIME", alias: "LDT", family: "dateTime", bits: 64 },
+  { name: "CHAR", family: "char", bits: 8 },
+  { name: "WCHAR", family: "char", bits: 16 },
+  { name: "STRING", family: "string" },
+  { name: "WSTRING", family: "string" }
+];
+var elementaryTypesByName = new Map(elementaryTypes.flatMap((type) => ("alias" in type) ? [
+  [type.name, type],
+  [type.alias, type]
+] : [[type.name, type]]));
+function elementaryType(name) {
+  return elementaryTypesByName.get(name);
+}
+var isIntegerValued = (type) => type?.family === "integer" || type?.family === "bits";
+var integerLimits = {
+  8: { signed: [-128n, 127n], unsigned: [0n, 255n] },
+  16: { signed: [-32768n, 32767n], unsigned: [0n, 65535n] },
+  32: {
+    signed: [-2147483648n, 2147483647n],
+    unsigned: [0n, 4294967295n]
+  },
+  64: {
+    signed: [-9223372036854775808n, 9223372036854775807n],
+    unsigned: [0n, 18446744073709551615n]
+  }
+};
+var integerRange = (layout) => integerLimits[layout.bits][layout.signed ? "signed" : "unsigned"];
+
+// packages/iec/src/direct-addresses.ts
+var sizePrefixes = new Map([
+  ["X", elementaryType("BOOL")],
+  ["B", elementaryType("BYTE")],
+  ["W", elementaryType("WORD")],
+  ["D", elementaryType("DWORD")],
+  ["L", elementaryType("LWORD")]
+]);
+var sizePrefix = (bits) => [...sizePrefixes].find(([, type]) => type.bits === bits)?.[0];
+var ioScalar = (type) => {
+  const scalar = elementaryType(type.trim().toUpperCase());
+  switch (scalar?.family) {
+    case "bool":
+    case "integer":
+    case "bits":
+    case "real":
+      return scalar;
+    case "duration":
+    case "date":
+    case "timeOfDay":
+    case "dateTime":
+      return scalar.bits === 32 ? scalar : undefined;
+    default:
+      return;
+  }
+};
+function ioScalarBits(type) {
+  return ioScalar(type)?.bits;
+}
+var ioArray = (type) => {
+  const array = /^ARRAY\s*\[\s*(-?\d+)\s*\.\.\s*(-?\d+)\s*\]\s*OF\s+(\w+)$/i.exec(type);
+  return array ? { element: array[3], length: Number(array[2]) - Number(array[1]) + 1 } : undefined;
+};
+export {
+  elementaryType,
+  elementaryTypes,
+  elementaryTypesByName,
+  integerRange,
+  ioArray,
+  ioScalar,
+  ioScalarBits,
+  isIntegerValued,
+  sizePrefix,
+  sizePrefixes
+};
+
+//# debugId=4E89C9555069E86664756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["../src/elementary-types.ts", "../src/direct-addresses.ts"],
+  "sourcesContent": [
+    "type IntegerBits = 8 | 16 | 32 | 64;\n\ntype ElementaryTypeShape =\n\t| { name: string; family: \"bool\"; bits: 1 }\n\t| { name: string; family: \"integer\"; bits: IntegerBits; signed: boolean }\n\t| { name: string; family: \"bits\"; bits: IntegerBits; signed: false }\n\t| { name: string; family: \"real\"; bits: 32 | 64 }\n\t| {\n\t\t\tname: string;\n\t\t\tfamily: \"duration\" | \"date\" | \"timeOfDay\" | \"dateTime\";\n\t\t\tbits: 32 | 64;\n\t\t\t/** The short name IEC also accepts, such as `TOD`. */\n\t\t\talias?: string;\n\t  }\n\t| { name: string; family: \"char\"; bits: 8 | 16 }\n\t| { name: string; family: \"string\" };\n\n/**\n * The IEC 61131-3 elementary types under their full names, with the widths CODESYS gives them.\n * BOOL is one bit, as a direct address lays it out; STRING and WSTRING take their length from\n * each declaration.\n */\nexport const elementaryTypes = [\n\t{ name: \"BOOL\", family: \"bool\", bits: 1 },\n\t{ name: \"SINT\", family: \"integer\", bits: 8, signed: true },\n\t{ name: \"INT\", family: \"integer\", bits: 16, signed: true },\n\t{ name: \"DINT\", family: \"integer\", bits: 32, signed: true },\n\t{ name: \"LINT\", family: \"integer\", bits: 64, signed: true },\n\t{ name: \"USINT\", family: \"integer\", bits: 8, signed: false },\n\t{ name: \"UINT\", family: \"integer\", bits: 16, signed: false },\n\t{ name: \"UDINT\", family: \"integer\", bits: 32, signed: false },\n\t{ name: \"ULINT\", family: \"integer\", bits: 64, signed: false },\n\t{ name: \"BYTE\", family: \"bits\", bits: 8, signed: false },\n\t{ name: \"WORD\", family: \"bits\", bits: 16, signed: false },\n\t{ name: \"DWORD\", family: \"bits\", bits: 32, signed: false },\n\t{ name: \"LWORD\", family: \"bits\", bits: 64, signed: false },\n\t{ name: \"REAL\", family: \"real\", bits: 32 },\n\t{ name: \"LREAL\", family: \"real\", bits: 64 },\n\t{ name: \"TIME\", family: \"duration\", bits: 32 },\n\t{ name: \"LTIME\", family: \"duration\", bits: 64 },\n\t{ name: \"DATE\", family: \"date\", bits: 32 },\n\t{ name: \"LDATE\", family: \"date\", bits: 64 },\n\t{ name: \"TIME_OF_DAY\", alias: \"TOD\", family: \"timeOfDay\", bits: 32 },\n\t{ name: \"LTIME_OF_DAY\", alias: \"LTOD\", family: \"timeOfDay\", bits: 64 },\n\t{ name: \"DATE_AND_TIME\", alias: \"DT\", family: \"dateTime\", bits: 32 },\n\t{ name: \"LDATE_AND_TIME\", alias: \"LDT\", family: \"dateTime\", bits: 64 },\n\t{ name: \"CHAR\", family: \"char\", bits: 8 },\n\t{ name: \"WCHAR\", family: \"char\", bits: 16 },\n\t{ name: \"STRING\", family: \"string\" },\n\t{ name: \"WSTRING\", family: \"string\" },\n] as const satisfies readonly ElementaryTypeShape[];\n\nexport type ElementaryType = (typeof elementaryTypes)[number];\n\n/**\n * Every elementary type by each name a program may write for it, its alias included. Keys are\n * upper case: IEC names are case-insensitive, so callers upper-case what they read.\n */\nexport const elementaryTypesByName: ReadonlyMap<string, ElementaryType> =\n\tnew Map(\n\t\telementaryTypes.flatMap((type): [string, ElementaryType][] =>\n\t\t\t\"alias\" in type\n\t\t\t\t? [\n\t\t\t\t\t\t[type.name, type],\n\t\t\t\t\t\t[type.alias, type],\n\t\t\t\t\t]\n\t\t\t\t: [[type.name, type]],\n\t\t),\n\t);\n\n/** The elementary type a name or alias stands for; a full name always finds its own type. */\nexport function elementaryType<Name extends ElementaryType[\"name\"]>(\n\tname: Name,\n): Extract<ElementaryType, { name: Name }>;\nexport function elementaryType(name: string): ElementaryType | undefined;\nexport function elementaryType(name: string): ElementaryType | undefined {\n\treturn elementaryTypesByName.get(name);\n}\n\n/** Integers and bit strings: the types whose values are whole numbers in a fixed range. */\nexport type IntegerValuedType = Extract<\n\tElementaryType,\n\t{ family: \"integer\" | \"bits\" }\n>;\n\nexport const isIntegerValued = (\n\ttype: ElementaryType | undefined,\n): type is IntegerValuedType =>\n\ttype?.family === \"integer\" || type?.family === \"bits\";\n\n// Literal, so a range can be a type as well as a value.\nconst integerLimits = {\n\t8: { signed: [-128n, 127n], unsigned: [0n, 255n] },\n\t16: { signed: [-32_768n, 32_767n], unsigned: [0n, 65_535n] },\n\t32: {\n\t\tsigned: [-2_147_483_648n, 2_147_483_647n],\n\t\tunsigned: [0n, 4_294_967_295n],\n\t},\n\t64: {\n\t\tsigned: [-9_223_372_036_854_775_808n, 9_223_372_036_854_775_807n],\n\t\tunsigned: [0n, 18_446_744_073_709_551_615n],\n\t},\n} as const;\n\ninterface IntegerLayout {\n\tbits: IntegerBits;\n\tsigned: boolean;\n}\n\n/** The least and greatest value of an integer layout, as literal types. */\nexport type IntegerRange<Layout extends IntegerLayout> =\n\t(typeof integerLimits)[Layout[\"bits\"]][Layout[\"signed\"] extends true\n\t\t? \"signed\"\n\t\t: \"unsigned\"];\n\n/** The least and greatest value of an integer layout; bit strings are unsigned. */\nexport const integerRange = (\n\tlayout: IntegerLayout,\n): readonly [bigint, bigint] =>\n\tintegerLimits[layout.bits][layout.signed ? \"signed\" : \"unsigned\"];\n",
+    "import { type ElementaryType, elementaryType } from \"./elementary-types.ts\";\n\n/** BOOL or a bit string: the type of a location a direct address names. */\ntype LocationType = Extract<ElementaryType, { family: \"bool\" | \"bits\" }>;\n\n/**\n * Each size prefix of a direct address (`%IX0.0`, `%QB4`, `%IW8`, `%ID12`, `%IL16`) with the\n * type of the location it names, which carries its width.\n */\nexport const sizePrefixes: ReadonlyMap<string, LocationType> = new Map<\n\tstring,\n\tLocationType\n>([\n\t[\"X\", elementaryType(\"BOOL\")],\n\t[\"B\", elementaryType(\"BYTE\")],\n\t[\"W\", elementaryType(\"WORD\")],\n\t[\"D\", elementaryType(\"DWORD\")],\n\t[\"L\", elementaryType(\"LWORD\")],\n]);\n\n/** The size prefix of a location `bits` wide. */\nexport const sizePrefix = (bits: number) =>\n\t[...sizePrefixes].find(([, type]) => type.bits === bits)?.[0];\n\n/**\n * The type of a scalar a process image carries: BOOL, an integer, bit string or real, or one\n * of the 32-bit date and time types.\n */\nexport const ioScalar = (type: string) => {\n\tconst scalar = elementaryType(type.trim().toUpperCase());\n\tswitch (scalar?.family) {\n\t\tcase \"bool\":\n\t\tcase \"integer\":\n\t\tcase \"bits\":\n\t\tcase \"real\":\n\t\t\treturn scalar;\n\t\tcase \"duration\":\n\t\tcase \"date\":\n\t\tcase \"timeOfDay\":\n\t\tcase \"dateTime\":\n\t\t\treturn scalar.bits === 32 ? scalar : undefined;\n\t\tdefault:\n\t\t\treturn undefined;\n\t}\n};\n\nexport function ioScalarBits(type: string): number | undefined {\n\treturn ioScalar(type)?.bits;\n}\n\n/**\n * The element type and length of a one-dimensional `ARRAY[l..u] OF T`: a span of consecutive\n * scalars binds at its first element's address.\n */\nexport const ioArray = (type: string) => {\n\tconst array =\n\t\t/^ARRAY\\s*\\[\\s*(-?\\d+)\\s*\\.\\.\\s*(-?\\d+)\\s*\\]\\s*OF\\s+(\\w+)$/i.exec(type);\n\treturn array\n\t\t? { element: array[3]!, length: Number(array[2]) - Number(array[1]) + 1 }\n\t\t: undefined;\n};\n"
+  ],
+  "mappings": "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",
+  "debugId": "4E89C9555069E86664756E2164756E21",
+  "names": []
+}

package/dist/st.js

@@ -0,0 +1,183 @@
+// packages/iec/src/st/lexical.ts
+var lineCommentEnd = (source, start) => {
+  const length = source.slice(start).search(/[\r\n]/);
+  return length < 0 ? source.length : start + length;
+};
+var blockCommentEnd = (source, start) => {
+  let depth = 1;
+  let offset = start + 2;
+  while (offset < source.length && depth > 0) {
+    if (source.startsWith("(*", offset)) {
+      depth++;
+      offset += 2;
+    } else if (source.startsWith("*)", offset)) {
+      depth--;
+      offset += 2;
+    } else {
+      offset++;
+    }
+  }
+  return depth > 0 ? null : offset;
+};
+var stringEnd = (source, start) => {
+  const delimiter = source[start];
+  let offset = start + 1;
+  while (offset < source.length) {
+    if (source[offset] === "$") {
+      offset += 2;
+    } else if (source[offset++] === delimiter) {
+      return offset;
+    }
+  }
+  return null;
+};
+var escapeString = (text, delimiter) => {
+  let escaped = "";
+  for (const character of text) {
+    const code = character.charCodeAt(0);
+    if (character === "$" || character === delimiter) {
+      escaped += `$${character}`;
+    } else if (code < 32 || code === 127) {
+      escaped += `$${code.toString(16).toUpperCase().padStart(delimiter === '"' ? 4 : 2, "0")}`;
+    } else {
+      escaped += character;
+    }
+  }
+  return escaped;
+};
+var directAddressEnd = (source, start) => {
+  const address = /^%[IQM][XBWDL]?(?:\d+(?:\.\d+)*|\*)/i.exec(source.slice(start))?.[0];
+  return address === undefined ? null : start + address.length;
+};
+var identifierPattern = /^[A-Za-z_][A-Za-z_0-9]*$/;
+// packages/iec/src/st/vocabulary.ts
+var objectKeywords = [
+  "PROGRAM",
+  "FUNCTION_BLOCK",
+  "FUNCTION",
+  "METHOD",
+  "PROPERTY",
+  "INTERFACE"
+];
+var globalSections = new Set(["VAR_GLOBAL", "VAR_CONFIG"]);
+var variableSections = new Set([
+  ...globalSections,
+  "VAR",
+  "VAR_INPUT",
+  "VAR_OUTPUT",
+  "VAR_IN_OUT",
+  "VAR_TEMP",
+  "VAR_STAT",
+  "VAR_INST",
+  "VAR_EXTERNAL",
+  "VAR_ACCESS",
+  "VAR_GENERIC"
+]);
+var modifiers = new Set([
+  "PUBLIC",
+  "PRIVATE",
+  "PROTECTED",
+  "INTERNAL",
+  "ABSTRACT",
+  "FINAL",
+  "OVERRIDE"
+]);
+var qualifiers = new Set([
+  "CONSTANT",
+  "RETAIN",
+  "NON_RETAIN",
+  "PERSISTENT"
+]);
+var keywords = new Set([
+  ...objectKeywords,
+  ...objectKeywords.map((keyword) => `END_${keyword}`),
+  ...variableSections,
+  "END_VAR",
+  ...modifiers,
+  ...qualifiers,
+  "TYPE",
+  "END_TYPE",
+  "STRUCT",
+  "END_STRUCT",
+  "UNION",
+  "END_UNION",
+  "EXTENDS",
+  "IMPLEMENTS",
+  "IF",
+  "THEN",
+  "ELSIF",
+  "ELSE",
+  "END_IF",
+  "CASE",
+  "OF",
+  "END_CASE",
+  "FOR",
+  "TO",
+  "BY",
+  "DO",
+  "END_FOR",
+  "WHILE",
+  "END_WHILE",
+  "REPEAT",
+  "UNTIL",
+  "END_REPEAT",
+  "EXIT",
+  "CONTINUE",
+  "RETURN",
+  "AND",
+  "AND_THEN",
+  "OR",
+  "OR_ELSE",
+  "XOR",
+  "NOT",
+  "MOD",
+  "ARRAY",
+  "POINTER",
+  "REFERENCE",
+  "REF_TO",
+  "AT",
+  "TRUE",
+  "FALSE",
+  "THIS",
+  "SUPER"
+]);
+var reservedWords = new Set([
+  ...keywords,
+  "FUNCTIONBLOCK",
+  "END_FUNCTIONBLOCK",
+  "ACTION",
+  "END_ACTION",
+  "CONFIGURATION",
+  "END_CONFIGURATION",
+  "RESOURCE",
+  "END_RESOURCE",
+  "TASK",
+  "WITH",
+  "SINGLE",
+  "INTERVAL",
+  "PRIORITY",
+  "READ_ONLY",
+  "READ_WRITE",
+  "PARAMS",
+  "JMP"
+]);
+var conditionalDirective = (pragma) => /^\{\s*(IF|ELSIF|ELSE|END_IF)\b/i.exec(pragma)?.[1]?.toUpperCase();
+export {
+  blockCommentEnd,
+  conditionalDirective,
+  directAddressEnd,
+  escapeString,
+  globalSections,
+  identifierPattern,
+  keywords,
+  lineCommentEnd,
+  modifiers,
+  objectKeywords,
+  qualifiers,
+  reservedWords,
+  stringEnd,
+  variableSections
+};
+
+//# debugId=BA160C07C649F5B064756E2164756E21
+//# sourceMappingURL=st.js.map

package/dist/st.js.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["../src/st/lexical.ts", "../src/st/vocabulary.ts"],
+  "sourcesContent": [
+    "/** Offset where a `//` comment starting at `start` ends: before the line break. */\nexport const lineCommentEnd = (source: string, start: number): number => {\n\tconst length = source.slice(start).search(/[\\r\\n]/);\n\treturn length < 0 ? source.length : start + length;\n};\n\n/** Offset just past a `(* *)` comment starting at `start`, or `null` when it never closes. Comments nest. */\nexport const blockCommentEnd = (\n\tsource: string,\n\tstart: number,\n): number | null => {\n\tlet depth = 1;\n\tlet offset = start + 2;\n\twhile (offset < source.length && depth > 0) {\n\t\tif (source.startsWith(\"(*\", offset)) {\n\t\t\tdepth++;\n\t\t\toffset += 2;\n\t\t} else if (source.startsWith(\"*)\", offset)) {\n\t\t\tdepth--;\n\t\t\toffset += 2;\n\t\t} else {\n\t\t\toffset++;\n\t\t}\n\t}\n\treturn depth > 0 ? null : offset;\n};\n\n/** Offset just past a `'` or `\"` string starting at `start`, or `null` when it never closes. */\nexport const stringEnd = (source: string, start: number): number | null => {\n\tconst delimiter = source[start];\n\tlet offset = start + 1;\n\twhile (offset < source.length) {\n\t\t// IEC strings escape characters (including quotes and $ itself) with $.\n\t\tif (source[offset] === \"$\") {\n\t\t\toffset += 2;\n\t\t} else if (source[offset++] === delimiter) {\n\t\t\treturn offset;\n\t\t}\n\t}\n\treturn null;\n};\n\n/**\n * `text` as it reads between the delimiters of an ST string literal, `'` for STRING and `\"` for\n * WSTRING: `$`, the delimiter and every control character escaped, the last as its code.\n */\nexport const escapeString = (text: string, delimiter: \"'\" | '\"') => {\n\tlet escaped = \"\";\n\tfor (const character of text) {\n\t\tconst code = character.charCodeAt(0);\n\t\tif (character === \"$\" || character === delimiter) {\n\t\t\tescaped += `$${character}`;\n\t\t} else if (code < 32 || code === 127) {\n\t\t\tescaped += `$${code\n\t\t\t\t.toString(16)\n\t\t\t\t.toUpperCase()\n\t\t\t\t.padStart(delimiter === '\"' ? 4 : 2, \"0\")}`;\n\t\t} else {\n\t\t\tescaped += character;\n\t\t}\n\t}\n\treturn escaped;\n};\n\n/** Offset just past a direct address such as `%IX0.0`, `%QW4` or `%I*` at `start`, or `null` when there is none. */\nexport const directAddressEnd = (\n\tsource: string,\n\tstart: number,\n): number | null => {\n\tconst address = /^%[IQM][XBWDL]?(?:\\d+(?:\\.\\d+)*|\\*)/i.exec(\n\t\tsource.slice(start),\n\t)?.[0];\n\treturn address === undefined ? null : start + address.length;\n};\n\n/** A complete IEC identifier: a letter or underscore, then letters, digits and underscores. */\nexport const identifierPattern = /^[A-Za-z_][A-Za-z_0-9]*$/;\n",
+    "/** Keywords that open a CODESYS object; each closes with `END_<keyword>`. */\nexport const objectKeywords = [\n\t\"PROGRAM\",\n\t\"FUNCTION_BLOCK\",\n\t\"FUNCTION\",\n\t\"METHOD\",\n\t\"PROPERTY\",\n\t\"INTERFACE\",\n] as const;\nexport type ObjectKeyword = (typeof objectKeywords)[number];\n\n/** Sections that make a file a global variable list rather than an object. */\nexport const globalSections = new Set([\"VAR_GLOBAL\", \"VAR_CONFIG\"]);\nexport const variableSections = new Set([\n\t...globalSections,\n\t\"VAR\",\n\t\"VAR_INPUT\",\n\t\"VAR_OUTPUT\",\n\t\"VAR_IN_OUT\",\n\t\"VAR_TEMP\",\n\t\"VAR_STAT\",\n\t\"VAR_INST\",\n\t\"VAR_EXTERNAL\",\n\t\"VAR_ACCESS\",\n\t\"VAR_GENERIC\",\n]);\n/** Access and inheritance modifiers written after an object keyword. */\nexport const modifiers = new Set([\n\t\"PUBLIC\",\n\t\"PRIVATE\",\n\t\"PROTECTED\",\n\t\"INTERNAL\",\n\t\"ABSTRACT\",\n\t\"FINAL\",\n\t\"OVERRIDE\",\n]);\n/** Qualifiers written after a variable section keyword. */\nexport const qualifiers = new Set([\n\t\"CONSTANT\",\n\t\"RETAIN\",\n\t\"NON_RETAIN\",\n\t\"PERSISTENT\",\n]);\n\n/** Words the Structured Text grammar gives a meaning. */\nexport const keywords = new Set([\n\t...objectKeywords,\n\t...objectKeywords.map((keyword) => `END_${keyword}`),\n\t...variableSections,\n\t\"END_VAR\",\n\t...modifiers,\n\t...qualifiers,\n\t\"TYPE\",\n\t\"END_TYPE\",\n\t\"STRUCT\",\n\t\"END_STRUCT\",\n\t\"UNION\",\n\t\"END_UNION\",\n\t\"EXTENDS\",\n\t\"IMPLEMENTS\",\n\t\"IF\",\n\t\"THEN\",\n\t\"ELSIF\",\n\t\"ELSE\",\n\t\"END_IF\",\n\t\"CASE\",\n\t\"OF\",\n\t\"END_CASE\",\n\t\"FOR\",\n\t\"TO\",\n\t\"BY\",\n\t\"DO\",\n\t\"END_FOR\",\n\t\"WHILE\",\n\t\"END_WHILE\",\n\t\"REPEAT\",\n\t\"UNTIL\",\n\t\"END_REPEAT\",\n\t\"EXIT\",\n\t\"CONTINUE\",\n\t\"RETURN\",\n\t\"AND\",\n\t\"AND_THEN\",\n\t\"OR\",\n\t\"OR_ELSE\",\n\t\"XOR\",\n\t\"NOT\",\n\t\"MOD\",\n\t\"ARRAY\",\n\t\"POINTER\",\n\t\"REFERENCE\",\n\t\"REF_TO\",\n\t\"AT\",\n\t\"TRUE\",\n\t\"FALSE\",\n\t\"THIS\",\n\t\"SUPER\",\n]);\n\n/**\n * Every word CODESYS reserves. Beyond the grammar keywords these are the export\n * format's ACTION, configuration and access-path keywords, Instruction List's\n * JMP, and the legacy FUNCTIONBLOCK spelling the importer still reads.\n */\nexport const reservedWords = new Set([\n\t...keywords,\n\t\"FUNCTIONBLOCK\",\n\t\"END_FUNCTIONBLOCK\",\n\t\"ACTION\",\n\t\"END_ACTION\",\n\t\"CONFIGURATION\",\n\t\"END_CONFIGURATION\",\n\t\"RESOURCE\",\n\t\"END_RESOURCE\",\n\t\"TASK\",\n\t\"WITH\",\n\t\"SINGLE\",\n\t\"INTERVAL\",\n\t\"PRIORITY\",\n\t\"READ_ONLY\",\n\t\"READ_WRITE\",\n\t\"PARAMS\",\n\t\"JMP\",\n]);\n\n/** The directive of a conditional-compilation pragma such as `{IF defined(DEBUG)}`. */\nexport const conditionalDirective = (pragma: string) =>\n\t/^\\{\\s*(IF|ELSIF|ELSE|END_IF)\\b/i.exec(pragma)?.[1]?.toUpperCase();\n"
+  ],
+  "mappings": "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",
+  "debugId": "BA160C07C649F5B064756E2164756E21",
+  "names": []
+}

package/package.json

@@ -1,6 +1,32 @@
 {
-  "name": "@tsplc/iec",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@tsplc/iec",
+	"version": "0.2.18",
+	"type": "module",
+	"license": "MIT",
+	"description": "IEC 61131-3 vocabulary shared by the tsPLC toolchain: elementary types and Structured Text syntax.",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/rip-technologies/tsplc.git",
+		"directory": "packages/iec"
+	},
+	"exports": {
+		".": {
+			"types": "./src/index.ts",
+			"bun": "./src/index.ts",
+			"default": "./dist/index.js"
+		},
+		"./st": {
+			"types": "./src/st/index.ts",
+			"bun": "./src/st/index.ts",
+			"default": "./dist/st.js"
+		}
+	},
+	"files": [
+		"dist",
+		"src",
+		"!**/*.test.ts"
+	],
+	"publishConfig": {
+		"access": "public"
+	}
+}

package/src/direct-addresses.ts

@@ -0,0 +1,61 @@
+import { type ElementaryType, elementaryType } from "./elementary-types.ts";
+
+/** BOOL or a bit string: the type of a location a direct address names. */
+type LocationType = Extract<ElementaryType, { family: "bool" | "bits" }>;
+
+/**
+ * Each size prefix of a direct address (`%IX0.0`, `%QB4`, `%IW8`, `%ID12`, `%IL16`) with the
+ * type of the location it names, which carries its width.
+ */
+export const sizePrefixes: ReadonlyMap<string, LocationType> = new Map<
+	string,
+	LocationType
+>([
+	["X", elementaryType("BOOL")],
+	["B", elementaryType("BYTE")],
+	["W", elementaryType("WORD")],
+	["D", elementaryType("DWORD")],
+	["L", elementaryType("LWORD")],
+]);
+
+/** The size prefix of a location `bits` wide. */
+export const sizePrefix = (bits: number) =>
+	[...sizePrefixes].find(([, type]) => type.bits === bits)?.[0];
+
+/**
+ * The type of a scalar a process image carries: BOOL, an integer, bit string or real, or one
+ * of the 32-bit date and time types.
+ */
+export const ioScalar = (type: string) => {
+	const scalar = elementaryType(type.trim().toUpperCase());
+	switch (scalar?.family) {
+		case "bool":
+		case "integer":
+		case "bits":
+		case "real":
+			return scalar;
+		case "duration":
+		case "date":
+		case "timeOfDay":
+		case "dateTime":
+			return scalar.bits === 32 ? scalar : undefined;
+		default:
+			return undefined;
+	}
+};
+
+export function ioScalarBits(type: string): number | undefined {
+	return ioScalar(type)?.bits;
+}
+
+/**
+ * The element type and length of a one-dimensional `ARRAY[l..u] OF T`: a span of consecutive
+ * scalars binds at its first element's address.
+ */
+export const ioArray = (type: string) => {
+	const array =
+		/^ARRAY\s*\[\s*(-?\d+)\s*\.\.\s*(-?\d+)\s*\]\s*OF\s+(\w+)$/i.exec(type);
+	return array
+		? { element: array[3]!, length: Number(array[2]) - Number(array[1]) + 1 }
+		: undefined;
+};

package/src/elementary-types.ts

@@ -0,0 +1,120 @@
+type IntegerBits = 8 | 16 | 32 | 64;
+
+type ElementaryTypeShape =
+	| { name: string; family: "bool"; bits: 1 }
+	| { name: string; family: "integer"; bits: IntegerBits; signed: boolean }
+	| { name: string; family: "bits"; bits: IntegerBits; signed: false }
+	| { name: string; family: "real"; bits: 32 | 64 }
+	| {
+			name: string;
+			family: "duration" | "date" | "timeOfDay" | "dateTime";
+			bits: 32 | 64;
+			/** The short name IEC also accepts, such as `TOD`. */
+			alias?: string;
+	  }
+	| { name: string; family: "char"; bits: 8 | 16 }
+	| { name: string; family: "string" };
+
+/**
+ * The IEC 61131-3 elementary types under their full names, with the widths CODESYS gives them.
+ * BOOL is one bit, as a direct address lays it out; STRING and WSTRING take their length from
+ * each declaration.
+ */
+export const elementaryTypes = [
+	{ name: "BOOL", family: "bool", bits: 1 },
+	{ name: "SINT", family: "integer", bits: 8, signed: true },
+	{ name: "INT", family: "integer", bits: 16, signed: true },
+	{ name: "DINT", family: "integer", bits: 32, signed: true },
+	{ name: "LINT", family: "integer", bits: 64, signed: true },
+	{ name: "USINT", family: "integer", bits: 8, signed: false },
+	{ name: "UINT", family: "integer", bits: 16, signed: false },
+	{ name: "UDINT", family: "integer", bits: 32, signed: false },
+	{ name: "ULINT", family: "integer", bits: 64, signed: false },
+	{ name: "BYTE", family: "bits", bits: 8, signed: false },
+	{ name: "WORD", family: "bits", bits: 16, signed: false },
+	{ name: "DWORD", family: "bits", bits: 32, signed: false },
+	{ name: "LWORD", family: "bits", bits: 64, signed: false },
+	{ name: "REAL", family: "real", bits: 32 },
+	{ name: "LREAL", family: "real", bits: 64 },
+	{ name: "TIME", family: "duration", bits: 32 },
+	{ name: "LTIME", family: "duration", bits: 64 },
+	{ name: "DATE", family: "date", bits: 32 },
+	{ name: "LDATE", family: "date", bits: 64 },
+	{ name: "TIME_OF_DAY", alias: "TOD", family: "timeOfDay", bits: 32 },
+	{ name: "LTIME_OF_DAY", alias: "LTOD", family: "timeOfDay", bits: 64 },
+	{ name: "DATE_AND_TIME", alias: "DT", family: "dateTime", bits: 32 },
+	{ name: "LDATE_AND_TIME", alias: "LDT", family: "dateTime", bits: 64 },
+	{ name: "CHAR", family: "char", bits: 8 },
+	{ name: "WCHAR", family: "char", bits: 16 },
+	{ name: "STRING", family: "string" },
+	{ name: "WSTRING", family: "string" },
+] as const satisfies readonly ElementaryTypeShape[];
+
+export type ElementaryType = (typeof elementaryTypes)[number];
+
+/**
+ * Every elementary type by each name a program may write for it, its alias included. Keys are
+ * upper case: IEC names are case-insensitive, so callers upper-case what they read.
+ */
+export const elementaryTypesByName: ReadonlyMap<string, ElementaryType> =
+	new Map(
+		elementaryTypes.flatMap((type): [string, ElementaryType][] =>
+			"alias" in type
+				? [
+						[type.name, type],
+						[type.alias, type],
+					]
+				: [[type.name, type]],
+		),
+	);
+
+/** The elementary type a name or alias stands for; a full name always finds its own type. */
+export function elementaryType<Name extends ElementaryType["name"]>(
+	name: Name,
+): Extract<ElementaryType, { name: Name }>;
+export function elementaryType(name: string): ElementaryType | undefined;
+export function elementaryType(name: string): ElementaryType | undefined {
+	return elementaryTypesByName.get(name);
+}
+
+/** Integers and bit strings: the types whose values are whole numbers in a fixed range. */
+export type IntegerValuedType = Extract<
+	ElementaryType,
+	{ family: "integer" | "bits" }
+>;
+
+export const isIntegerValued = (
+	type: ElementaryType | undefined,
+): type is IntegerValuedType =>
+	type?.family === "integer" || type?.family === "bits";
+
+// Literal, so a range can be a type as well as a value.
+const integerLimits = {
+	8: { signed: [-128n, 127n], unsigned: [0n, 255n] },
+	16: { signed: [-32_768n, 32_767n], unsigned: [0n, 65_535n] },
+	32: {
+		signed: [-2_147_483_648n, 2_147_483_647n],
+		unsigned: [0n, 4_294_967_295n],
+	},
+	64: {
+		signed: [-9_223_372_036_854_775_808n, 9_223_372_036_854_775_807n],
+		unsigned: [0n, 18_446_744_073_709_551_615n],
+	},
+} as const;
+
+interface IntegerLayout {
+	bits: IntegerBits;
+	signed: boolean;
+}
+
+/** The least and greatest value of an integer layout, as literal types. */
+export type IntegerRange<Layout extends IntegerLayout> =
+	(typeof integerLimits)[Layout["bits"]][Layout["signed"] extends true
+		? "signed"
+		: "unsigned"];
+
+/** The least and greatest value of an integer layout; bit strings are unsigned. */
+export const integerRange = (
+	layout: IntegerLayout,
+): readonly [bigint, bigint] =>
+	integerLimits[layout.bits][layout.signed ? "signed" : "unsigned"];

package/src/index.ts

@@ -0,0 +1,17 @@
+export {
+	ioArray,
+	ioScalar,
+	ioScalarBits,
+	sizePrefix,
+	sizePrefixes,
+} from "./direct-addresses.ts";
+export {
+	type ElementaryType,
+	type IntegerRange,
+	type IntegerValuedType,
+	elementaryType,
+	elementaryTypes,
+	elementaryTypesByName,
+	integerRange,
+	isIntegerValued,
+} from "./elementary-types.ts";

package/src/st/index.ts

@@ -0,0 +1,19 @@
+export {
+	blockCommentEnd,
+	directAddressEnd,
+	escapeString,
+	identifierPattern,
+	lineCommentEnd,
+	stringEnd,
+} from "./lexical";
+export {
+	conditionalDirective,
+	globalSections,
+	keywords,
+	modifiers,
+	type ObjectKeyword,
+	objectKeywords,
+	qualifiers,
+	reservedWords,
+	variableSections,
+} from "./vocabulary";

package/src/st/lexical.ts

@@ -0,0 +1,77 @@
+/** Offset where a `//` comment starting at `start` ends: before the line break. */
+export const lineCommentEnd = (source: string, start: number): number => {
+	const length = source.slice(start).search(/[\r\n]/);
+	return length < 0 ? source.length : start + length;
+};
+
+/** Offset just past a `(* *)` comment starting at `start`, or `null` when it never closes. Comments nest. */
+export const blockCommentEnd = (
+	source: string,
+	start: number,
+): number | null => {
+	let depth = 1;
+	let offset = start + 2;
+	while (offset < source.length && depth > 0) {
+		if (source.startsWith("(*", offset)) {
+			depth++;
+			offset += 2;
+		} else if (source.startsWith("*)", offset)) {
+			depth--;
+			offset += 2;
+		} else {
+			offset++;
+		}
+	}
+	return depth > 0 ? null : offset;
+};
+
+/** Offset just past a `'` or `"` string starting at `start`, or `null` when it never closes. */
+export const stringEnd = (source: string, start: number): number | null => {
+	const delimiter = source[start];
+	let offset = start + 1;
+	while (offset < source.length) {
+		// IEC strings escape characters (including quotes and $ itself) with $.
+		if (source[offset] === "$") {
+			offset += 2;
+		} else if (source[offset++] === delimiter) {
+			return offset;
+		}
+	}
+	return null;
+};
+
+/**
+ * `text` as it reads between the delimiters of an ST string literal, `'` for STRING and `"` for
+ * WSTRING: `$`, the delimiter and every control character escaped, the last as its code.
+ */
+export const escapeString = (text: string, delimiter: "'" | '"') => {
+	let escaped = "";
+	for (const character of text) {
+		const code = character.charCodeAt(0);
+		if (character === "$" || character === delimiter) {
+			escaped += `$${character}`;
+		} else if (code < 32 || code === 127) {
+			escaped += `$${code
+				.toString(16)
+				.toUpperCase()
+				.padStart(delimiter === '"' ? 4 : 2, "0")}`;
+		} else {
+			escaped += character;
+		}
+	}
+	return escaped;
+};
+
+/** Offset just past a direct address such as `%IX0.0`, `%QW4` or `%I*` at `start`, or `null` when there is none. */
+export const directAddressEnd = (
+	source: string,
+	start: number,
+): number | null => {
+	const address = /^%[IQM][XBWDL]?(?:\d+(?:\.\d+)*|\*)/i.exec(
+		source.slice(start),
+	)?.[0];
+	return address === undefined ? null : start + address.length;
+};
+
+/** A complete IEC identifier: a letter or underscore, then letters, digits and underscores. */
+export const identifierPattern = /^[A-Za-z_][A-Za-z_0-9]*$/;

package/src/st/vocabulary.ts

@@ -0,0 +1,128 @@
+/** Keywords that open a CODESYS object; each closes with `END_<keyword>`. */
+export const objectKeywords = [
+	"PROGRAM",
+	"FUNCTION_BLOCK",
+	"FUNCTION",
+	"METHOD",
+	"PROPERTY",
+	"INTERFACE",
+] as const;
+export type ObjectKeyword = (typeof objectKeywords)[number];
+
+/** Sections that make a file a global variable list rather than an object. */
+export const globalSections = new Set(["VAR_GLOBAL", "VAR_CONFIG"]);
+export const variableSections = new Set([
+	...globalSections,
+	"VAR",
+	"VAR_INPUT",
+	"VAR_OUTPUT",
+	"VAR_IN_OUT",
+	"VAR_TEMP",
+	"VAR_STAT",
+	"VAR_INST",
+	"VAR_EXTERNAL",
+	"VAR_ACCESS",
+	"VAR_GENERIC",
+]);
+/** Access and inheritance modifiers written after an object keyword. */
+export const modifiers = new Set([
+	"PUBLIC",
+	"PRIVATE",
+	"PROTECTED",
+	"INTERNAL",
+	"ABSTRACT",
+	"FINAL",
+	"OVERRIDE",
+]);
+/** Qualifiers written after a variable section keyword. */
+export const qualifiers = new Set([
+	"CONSTANT",
+	"RETAIN",
+	"NON_RETAIN",
+	"PERSISTENT",
+]);
+
+/** Words the Structured Text grammar gives a meaning. */
+export const keywords = new Set([
+	...objectKeywords,
+	...objectKeywords.map((keyword) => `END_${keyword}`),
+	...variableSections,
+	"END_VAR",
+	...modifiers,
+	...qualifiers,
+	"TYPE",
+	"END_TYPE",
+	"STRUCT",
+	"END_STRUCT",
+	"UNION",
+	"END_UNION",
+	"EXTENDS",
+	"IMPLEMENTS",
+	"IF",
+	"THEN",
+	"ELSIF",
+	"ELSE",
+	"END_IF",
+	"CASE",
+	"OF",
+	"END_CASE",
+	"FOR",
+	"TO",
+	"BY",
+	"DO",
+	"END_FOR",
+	"WHILE",
+	"END_WHILE",
+	"REPEAT",
+	"UNTIL",
+	"END_REPEAT",
+	"EXIT",
+	"CONTINUE",
+	"RETURN",
+	"AND",
+	"AND_THEN",
+	"OR",
+	"OR_ELSE",
+	"XOR",
+	"NOT",
+	"MOD",
+	"ARRAY",
+	"POINTER",
+	"REFERENCE",
+	"REF_TO",
+	"AT",
+	"TRUE",
+	"FALSE",
+	"THIS",
+	"SUPER",
+]);
+
+/**
+ * Every word CODESYS reserves. Beyond the grammar keywords these are the export
+ * format's ACTION, configuration and access-path keywords, Instruction List's
+ * JMP, and the legacy FUNCTIONBLOCK spelling the importer still reads.
+ */
+export const reservedWords = new Set([
+	...keywords,
+	"FUNCTIONBLOCK",
+	"END_FUNCTIONBLOCK",
+	"ACTION",
+	"END_ACTION",
+	"CONFIGURATION",
+	"END_CONFIGURATION",
+	"RESOURCE",
+	"END_RESOURCE",
+	"TASK",
+	"WITH",
+	"SINGLE",
+	"INTERVAL",
+	"PRIORITY",
+	"READ_ONLY",
+	"READ_WRITE",
+	"PARAMS",
+	"JMP",
+]);
+
+/** The directive of a conditional-compilation pragma such as `{IF defined(DEBUG)}`. */
+export const conditionalDirective = (pragma: string) =>
+	/^\{\s*(IF|ELSIF|ELSE|END_IF)\b/i.exec(pragma)?.[1]?.toUpperCase();